]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/infiniband/ulp/srp/ib_srp.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
IB/srp: Introduce the helper function srp_remove_target()
[mirror_ubuntu-bionic-kernel.git] / drivers / infiniband / ulp / srp / ib_srp.c
CommitLineData
aef9ec39
RD		 1/*
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.
aef9ec39
RD		 31 */
32
e0bda7d8
BVA		 33#define pr_fmt(fmt) PFX fmt
34
aef9ec39
RD		 35#include <linux/module.h>
36#include <linux/init.h>
37#include <linux/slab.h>
38#include <linux/err.h>
39#include <linux/string.h>
40#include <linux/parser.h>
41#include <linux/random.h>
de25968c 42#include <linux/jiffies.h>
aef9ec39 43
60063497 44#include <linux/atomic.h>
aef9ec39
RD		 45
46#include <scsi/scsi.h>
47#include <scsi/scsi_device.h>
48#include <scsi/scsi_dbg.h>
49#include <scsi/srp.h>
3236822b 50#include <scsi/scsi_transport_srp.h>
aef9ec39 51
aef9ec39
RD		 52#include "ib_srp.h"
53
54#define DRV_NAME "ib_srp"
55#define PFX DRV_NAME ": "
56#define DRV_VERSION "0.2"
57#define DRV_RELDATE "November 1, 2005"
58
59MODULE_AUTHOR("Roland Dreier");
60MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator "
61 "v" DRV_VERSION " (" DRV_RELDATE ")");
62MODULE_LICENSE("Dual BSD/GPL");
63
49248644
DD		 64static unsigned int srp_sg_tablesize;
65static unsigned int cmd_sg_entries;
c07d424d
DD		 66static unsigned int indirect_sg_entries;
67static bool allow_ext_sg;
49248644 68static int topspin_workarounds = 1;
74b0a15b 69
49248644
DD		 70module_param(srp_sg_tablesize, uint, 0444);
71MODULE_PARM_DESC(srp_sg_tablesize, "Deprecated name for cmd_sg_entries");
74b0a15b 72
49248644
DD		 73module_param(cmd_sg_entries, uint, 0444);
74MODULE_PARM_DESC(cmd_sg_entries,
75 "Default number of gather/scatter entries in the SRP command (default is 12, max 255)");
aef9ec39 76
c07d424d
DD		 77module_param(indirect_sg_entries, uint, 0444);
78MODULE_PARM_DESC(indirect_sg_entries,
79 "Default max number of gather/scatter entries (default is 12, max is " __stringify(SCSI_MAX_SG_CHAIN_SEGMENTS) ")");
80
81module_param(allow_ext_sg, bool, 0444);
82MODULE_PARM_DESC(allow_ext_sg,
83 "Default behavior when there are more than cmd_sg_entries S/G entries after mapping; fails the request when false (default false)");
84
aef9ec39
RD		 85module_param(topspin_workarounds, int, 0444);
86MODULE_PARM_DESC(topspin_workarounds,
87 "Enable workarounds for Topspin/Cisco SRP target bugs if != 0");
88
aef9ec39
RD		 89static void srp_add_one(struct ib_device *device);
90static void srp_remove_one(struct ib_device *device);
9c03dc9f
BVA		 91static void srp_recv_completion(struct ib_cq *cq, void *target_ptr);
92static void srp_send_completion(struct ib_cq *cq, void *target_ptr);
aef9ec39
RD		 93static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event);
94
3236822b
FT		 95static struct scsi_transport_template *ib_srp_transport_template;
96
aef9ec39
RD		 97static struct ib_client srp_client = {
98 .name = "srp",
99 .add = srp_add_one,
100 .remove = srp_remove_one
101};
102
c1a0b23b
MT		 103static struct ib_sa_client srp_sa_client;
104
aef9ec39
RD		 105static inline struct srp_target_port *host_to_target(struct Scsi_Host *host)
106{
107 return (struct srp_target_port *) host->hostdata;
108}
109
110static const char *srp_target_info(struct Scsi_Host *host)
111{
112 return host_to_target(host)->target_name;
113}
114
5d7cbfd6
RD		 115static int srp_target_is_topspin(struct srp_target_port *target)
116{
117 static const u8 topspin_oui[3] = { 0x00, 0x05, 0xad };
3d1ff48d 118 static const u8 cisco_oui[3] = { 0x00, 0x1b, 0x0d };
5d7cbfd6
RD		 119
120 return topspin_workarounds &&
3d1ff48d
RK		 121 (!memcmp(&target->ioc_guid, topspin_oui, sizeof topspin_oui) ||
122 !memcmp(&target->ioc_guid, cisco_oui, sizeof cisco_oui));
5d7cbfd6
RD		 123}
124
aef9ec39
RD		 125static 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
05321937
GKH		 139 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))
aef9ec39
RD		 142 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
05321937
GKH		 162 ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size,
163 iu->direction);
aef9ec39
RD		 164 kfree(iu->buf);
165 kfree(iu);
166}
167
168static void srp_qp_event(struct ib_event *event, void *context)
169{
e0bda7d8 170 pr_debug("QP event %d\n", event->event);
aef9ec39
RD		 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
969a60f9
RD		 183 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);
aef9ec39
RD		 187 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
9fe4bcf4
DD		 206static int srp_new_cm_id(struct srp_target_port *target)
207{
208 struct ib_cm_id *new_cm_id;
209
05321937 210 new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
9fe4bcf4
DD		 211 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
aef9ec39
RD		 222static 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
9c03dc9f
BVA		 231 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);
da9d2f07 235 goto err;
aef9ec39
RD		 236 }
237
9c03dc9f
BVA		 238 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);
da9d2f07 242 goto err_recv_cq;
9c03dc9f
BVA		 243 }
244
245 ib_req_notify_cq(target->recv_cq, IB_CQ_NEXT_COMP);
aef9ec39
RD		 246
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;
9c03dc9f
BVA		 254 init_attr->send_cq = target->send_cq;
255 init_attr->recv_cq = target->recv_cq;
aef9ec39 256
05321937 257 target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
aef9ec39
RD		 258 if (IS_ERR(target->qp)) {
259 ret = PTR_ERR(target->qp);
da9d2f07 260 goto err_send_cq;
aef9ec39
RD		 261 }
262
263 ret = srp_init_qp(target, target->qp);
da9d2f07
RD		 264 if (ret)
265 goto err_qp;
aef9ec39 266
da9d2f07
RD		 267 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:
aef9ec39
RD		 280 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);
9c03dc9f
BVA		 289 ib_destroy_cq(target->send_cq);
290 ib_destroy_cq(target->recv_cq);
aef9ec39
RD		 291
292 for (i = 0; i < SRP_RQ_SIZE; ++i)
293 srp_free_iu(target->srp_host, target->rx_ring[i]);
dd5e6e38 294 for (i = 0; i < SRP_SQ_SIZE; ++i)
aef9ec39
RD		 295 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)
7aa54bd7
DD		 306 shost_printk(KERN_ERR, target->scsi_host,
307 PFX "Got failed path rec status %d\n", status);
aef9ec39
RD		 308 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
c1a0b23b 319 target->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
05321937 320 target->srp_host->srp_dev->dev,
aef9ec39
RD		 321 target->srp_host->port,
322 &target->path,
247e020e 323 IB_SA_PATH_REC_SERVICE_ID |
aef9ec39
RD		 324 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)
7aa54bd7
DD		 338 shost_printk(KERN_WARNING, target->scsi_host,
339 PFX "Path record query failed\n");
aef9ec39
RD		 340
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;
49248644 381 req->priv.req_it_iu_len = cpu_to_be32(target->max_iu_len);
aef9ec39
RD		 382 req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
383 SRP_BUF_FORMAT_INDIRECT);
0c0450db 384 /*
3cd96564 385 * In the published SRP specification (draft rev. 16a), the
0c0450db
R		 386 * 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,
01cb9bcb 395 &target->path.sgid.global.interface_id, 8);
0c0450db 396 memcpy(req->priv.initiator_port_id + 8,
01cb9bcb 397 &target->initiator_ext, 8);
0c0450db
R		 398 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,
01cb9bcb
IR		 402 &target->initiator_ext, 8);
403 memcpy(req->priv.initiator_port_id + 8,
404 &target->path.sgid.global.interface_id, 8);
0c0450db
R		 405 memcpy(req->priv.target_port_id, &target->id_ext, 8);
406 memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8);
407 }
408
aef9ec39
RD		 409 /*
410 * Topspin/Cisco SRP targets will reject our login unless we
01cb9bcb
IR		 411 * zero out the first 8 bytes of our initiator port ID and set
412 * the second 8 bytes to the local node GUID.
aef9ec39 413 */
5d7cbfd6 414 if (srp_target_is_topspin(target)) {
7aa54bd7
DD		 415 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));
aef9ec39 419 memset(req->priv.initiator_port_id, 0, 8);
01cb9bcb 420 memcpy(req->priv.initiator_port_id + 8,
05321937 421 &target->srp_host->srp_dev->dev->node_guid, 8);
aef9ec39 422 }
aef9ec39
RD		 423
424 status = ib_send_cm_req(target->cm_id, &req->param);
425
426 kfree(req);
427
428 return status;
429}
430
294c875a
BVA		 431static bool srp_change_conn_state(struct srp_target_port *target,
432 bool connected)
433{
434 bool changed = false;
435
436 spin_lock_irq(&target->lock);
437 if (target->connected != connected) {
438 target->connected = connected;
439 changed = true;
440 }
441 spin_unlock_irq(&target->lock);
442
443 return changed;
444}
445
aef9ec39
RD		 446static void srp_disconnect_target(struct srp_target_port *target)
447{
294c875a
BVA		 448 if (srp_change_conn_state(target, false)) {
449 /* XXX should send SRP_I_LOGOUT request */
aef9ec39 450
294c875a
BVA		 451 init_completion(&target->done);
452 if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
453 shost_printk(KERN_DEBUG, target->scsi_host,
454 PFX "Sending CM DREQ failed\n");
455 } else {
456 wait_for_completion(&target->done);
457 }
e6581056 458 }
aef9ec39
RD		 459}
460
9709f0e0
BVA		 461static bool srp_change_state(struct srp_target_port *target,
462 enum srp_target_state old,
463 enum srp_target_state new)
464{
465 bool changed = false;
466
e9684678 467 spin_lock_irq(&target->lock);
9709f0e0
BVA		 468 if (target->state == old) {
469 target->state = new;
470 changed = true;
471 }
e9684678 472 spin_unlock_irq(&target->lock);
9709f0e0
BVA		 473 return changed;
474}
475
8f26c9ff
DD		 476static void srp_free_req_data(struct srp_target_port *target)
477{
c07d424d 478 struct ib_device *ibdev = target->srp_host->srp_dev->dev;
8f26c9ff
DD		 479 struct srp_request *req;
480 int i;
481
482 for (i = 0, req = target->req_ring; i < SRP_CMD_SQ_SIZE; ++i, ++req) {
483 kfree(req->fmr_list);
484 kfree(req->map_page);
c07d424d
DD		 485 if (req->indirect_dma_addr) {
486 ib_dma_unmap_single(ibdev, req->indirect_dma_addr,
487 target->indirect_size,
488 DMA_TO_DEVICE);
489 }
490 kfree(req->indirect_desc);
8f26c9ff
DD		 491 }
492}
493
683b159a
BVA		 494/**
495 * srp_del_scsi_host_attr() - Remove attributes defined in the host template.
496 * @shost: SCSI host whose attributes to remove from sysfs.
497 *
498 * Note: Any attributes defined in the host template and that did not exist
499 * before invocation of this function will be ignored.
500 */
501static void srp_del_scsi_host_attr(struct Scsi_Host *shost)
502{
503 struct device_attribute **attr;
504
505 for (attr = shost->hostt->shost_attrs; attr && *attr; ++attr)
506 device_remove_file(&shost->shost_dev, *attr);
507}
508
ee12d6a8
BVA		 509static void srp_remove_target(struct srp_target_port *target)
510{
511 srp_del_scsi_host_attr(target->scsi_host);
512 srp_remove_host(target->scsi_host);
513 scsi_remove_host(target->scsi_host);
514 ib_destroy_cm_id(target->cm_id);
515 srp_free_target_ib(target);
516 srp_free_req_data(target);
517 scsi_host_put(target->scsi_host);
518}
519
c4028958 520static void srp_remove_work(struct work_struct *work)
aef9ec39 521{
c4028958
DH		 522 struct srp_target_port *target =
523 container_of(work, struct srp_target_port, work);
aef9ec39 524
9709f0e0 525 if (!srp_change_state(target, SRP_TARGET_DEAD, SRP_TARGET_REMOVED))
aef9ec39 526 return;
aef9ec39 527
b3589fd4 528 spin_lock(&target->srp_host->target_lock);
aef9ec39 529 list_del(&target->list);
b3589fd4 530 spin_unlock(&target->srp_host->target_lock);
aef9ec39 531
ee12d6a8 532 srp_remove_target(target);
aef9ec39
RD		 533}
534
535static int srp_connect_target(struct srp_target_port *target)
536{
9fe4bcf4 537 int retries = 3;
aef9ec39
RD		 538 int ret;
539
294c875a
BVA		 540 WARN_ON_ONCE(target->connected);
541
948d1e88
BVA		 542 target->qp_in_error = false;
543
aef9ec39
RD		 544 ret = srp_lookup_path(target);
545 if (ret)
546 return ret;
547
548 while (1) {
549 init_completion(&target->done);
550 ret = srp_send_req(target);
551 if (ret)
552 return ret;
553 wait_for_completion(&target->done);
554
555 /*
556 * The CM event handling code will set status to
557 * SRP_PORT_REDIRECT if we get a port redirect REJ
558 * back, or SRP_DLID_REDIRECT if we get a lid/qp
559 * redirect REJ back.
560 */
561 switch (target->status) {
562 case 0:
294c875a 563 srp_change_conn_state(target, true);
aef9ec39
RD		 564 return 0;
565
566 case SRP_PORT_REDIRECT:
567 ret = srp_lookup_path(target);
568 if (ret)
569 return ret;
570 break;
571
572 case SRP_DLID_REDIRECT:
573 break;
574
9fe4bcf4
DD		 575 case SRP_STALE_CONN:
576 /* Our current CM id was stale, and is now in timewait.
577 * Try to reconnect with a new one.
578 */
579 if (!retries-- || srp_new_cm_id(target)) {
580 shost_printk(KERN_ERR, target->scsi_host, PFX
581 "giving up on stale connection\n");
582 target->status = -ECONNRESET;
583 return target->status;
584 }
585
586 shost_printk(KERN_ERR, target->scsi_host, PFX
587 "retrying stale connection\n");
588 break;
589
aef9ec39
RD		 590 default:
591 return target->status;
592 }
593 }
594}
595
d945e1df
RD		 596static void srp_unmap_data(struct scsi_cmnd *scmnd,
597 struct srp_target_port *target,
598 struct srp_request *req)
599{
8f26c9ff
DD		 600 struct ib_device *ibdev = target->srp_host->srp_dev->dev;
601 struct ib_pool_fmr **pfmr;
602
bb350d1d 603 if (!scsi_sglist(scmnd) ||
d945e1df
RD		 604 (scmnd->sc_data_direction != DMA_TO_DEVICE &&
605 scmnd->sc_data_direction != DMA_FROM_DEVICE))
606 return;
607
8f26c9ff
DD		 608 pfmr = req->fmr_list;
609 while (req->nfmr--)
610 ib_fmr_pool_unmap(*pfmr++);
f5358a17 611
8f26c9ff
DD		 612 ib_dma_unmap_sg(ibdev, scsi_sglist(scmnd), scsi_sg_count(scmnd),
613 scmnd->sc_data_direction);
d945e1df
RD		 614}
615
22032991
BVA		 616/**
617 * srp_claim_req - Take ownership of the scmnd associated with a request.
618 * @target: SRP target port.
619 * @req: SRP request.
620 * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
621 * ownership of @req->scmnd if it equals @scmnd.
622 *
623 * Return value:
624 * Either NULL or a pointer to the SCSI command the caller became owner of.
625 */
626static struct scsi_cmnd *srp_claim_req(struct srp_target_port *target,
627 struct srp_request *req,
628 struct scsi_cmnd *scmnd)
629{
630 unsigned long flags;
631
632 spin_lock_irqsave(&target->lock, flags);
633 if (!scmnd) {
634 scmnd = req->scmnd;
635 req->scmnd = NULL;
636 } else if (req->scmnd == scmnd) {
637 req->scmnd = NULL;
638 } else {
639 scmnd = NULL;
640 }
641 spin_unlock_irqrestore(&target->lock, flags);
642
643 return scmnd;
644}
645
646/**
647 * srp_free_req() - Unmap data and add request to the free request list.
648 */
649static void srp_free_req(struct srp_target_port *target,
650 struct srp_request *req, struct scsi_cmnd *scmnd,
651 s32 req_lim_delta)
526b4caa 652{
94a9174c
BVA		 653 unsigned long flags;
654
22032991
BVA		 655 srp_unmap_data(scmnd, target, req);
656
e9684678 657 spin_lock_irqsave(&target->lock, flags);
94a9174c 658 target->req_lim += req_lim_delta;
536ae14e 659 list_add_tail(&req->list, &target->free_reqs);
e9684678 660 spin_unlock_irqrestore(&target->lock, flags);
526b4caa
IR		 661}
662
663static void srp_reset_req(struct srp_target_port *target, struct srp_request *req)
664{
22032991
BVA		 665 struct scsi_cmnd *scmnd = srp_claim_req(target, req, NULL);
666
667 if (scmnd) {
9b796d06 668 srp_free_req(target, req, scmnd, 0);
22032991
BVA		 669 scmnd->result = DID_RESET << 16;
670 scmnd->scsi_done(scmnd);
22032991 671 }
526b4caa
IR		 672}
673
aef9ec39
RD		 674static int srp_reconnect_target(struct srp_target_port *target)
675{
09be70a2 676 struct Scsi_Host *shost = target->scsi_host;
aef9ec39 677 struct ib_qp_attr qp_attr;
aef9ec39 678 struct ib_wc wc;
dcb4cb85 679 int i, ret;
aef9ec39 680
09be70a2 681 if (target->state != SRP_TARGET_LIVE)
aef9ec39 682 return -EAGAIN;
aef9ec39 683
09be70a2
BVA		 684 scsi_target_block(&shost->shost_gendev);
685
aef9ec39
RD		 686 srp_disconnect_target(target);
687 /*
688 * Now get a new local CM ID so that we avoid confusing the
689 * target in case things are really fouled up.
690 */
9fe4bcf4
DD		 691 ret = srp_new_cm_id(target);
692 if (ret)
09be70a2 693 goto unblock;
aef9ec39
RD		 694
695 qp_attr.qp_state = IB_QPS_RESET;
696 ret = ib_modify_qp(target->qp, &qp_attr, IB_QP_STATE);
697 if (ret)
09be70a2 698 goto unblock;
aef9ec39
RD		 699
700 ret = srp_init_qp(target, target->qp);
701 if (ret)
09be70a2 702 goto unblock;
aef9ec39 703
9c03dc9f
BVA		 704 while (ib_poll_cq(target->recv_cq, 1, &wc) > 0)
705 ; /* nothing */
706 while (ib_poll_cq(target->send_cq, 1, &wc) > 0)
aef9ec39
RD		 707 ; /* nothing */
708
536ae14e
BVA		 709 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
710 struct srp_request *req = &target->req_ring[i];
711 if (req->scmnd)
712 srp_reset_req(target, req);
713 }
aef9ec39 714
536ae14e 715 INIT_LIST_HEAD(&target->free_tx);
dcb4cb85 716 for (i = 0; i < SRP_SQ_SIZE; ++i)
536ae14e 717 list_add(&target->tx_ring[i]->list, &target->free_tx);
aef9ec39
RD		 718
719 ret = srp_connect_target(target);
09be70a2
BVA		 720
721unblock:
722 scsi_target_unblock(&shost->shost_gendev, ret == 0 ? SDEV_RUNNING :
723 SDEV_TRANSPORT_OFFLINE);
724
aef9ec39
RD		 725 if (ret)
726 goto err;
727
09be70a2 728 shost_printk(KERN_INFO, target->scsi_host, PFX "reconnect succeeded\n");
aef9ec39
RD		 729
730 return ret;
731
732err:
7aa54bd7
DD		 733 shost_printk(KERN_ERR, target->scsi_host,
734 PFX "reconnect failed (%d), removing target port.\n", ret);
aef9ec39
RD		 735
736 /*
737 * We couldn't reconnect, so kill our target port off.
9709f0e0
BVA		 738 * However, we have to defer the real removal because we
739 * are in the context of the SCSI error handler now, which
740 * will deadlock if we call scsi_remove_host().
741 *
742 * Schedule our work inside the lock to avoid a race with
743 * the flush_scheduled_work() in srp_remove_one().
aef9ec39 744 */
e9684678 745 spin_lock_irq(&target->lock);
09be70a2 746 if (target->state == SRP_TARGET_LIVE) {
aef9ec39 747 target->state = SRP_TARGET_DEAD;
c4028958 748 INIT_WORK(&target->work, srp_remove_work);
f0626710 749 queue_work(ib_wq, &target->work);
aef9ec39 750 }
e9684678 751 spin_unlock_irq(&target->lock);
aef9ec39
RD		 752
753 return ret;
754}
755
8f26c9ff
DD		 756static void srp_map_desc(struct srp_map_state *state, dma_addr_t dma_addr,
757 unsigned int dma_len, u32 rkey)
f5358a17 758{
8f26c9ff 759 struct srp_direct_buf *desc = state->desc;
f5358a17 760
8f26c9ff
DD		 761 desc->va = cpu_to_be64(dma_addr);
762 desc->key = cpu_to_be32(rkey);
763 desc->len = cpu_to_be32(dma_len);
f5358a17 764
8f26c9ff
DD		 765 state->total_len += dma_len;
766 state->desc++;
767 state->ndesc++;
768}
559ce8f1 769
8f26c9ff
DD		 770static int srp_map_finish_fmr(struct srp_map_state *state,
771 struct srp_target_port *target)
772{
773 struct srp_device *dev = target->srp_host->srp_dev;
774 struct ib_pool_fmr *fmr;
775 u64 io_addr = 0;
85507bcc 776
8f26c9ff
DD		 777 if (!state->npages)
778 return 0;
f5358a17 779
8f26c9ff
DD		 780 if (state->npages == 1) {
781 srp_map_desc(state, state->base_dma_addr, state->fmr_len,
782 target->rkey);
783 state->npages = state->fmr_len = 0;
784 return 0;
f5358a17
RD		 785 }
786
8f26c9ff
DD		 787 fmr = ib_fmr_pool_map_phys(dev->fmr_pool, state->pages,
788 state->npages, io_addr);
789 if (IS_ERR(fmr))
790 return PTR_ERR(fmr);
f5358a17 791
8f26c9ff
DD		 792 *state->next_fmr++ = fmr;
793 state->nfmr++;
f5358a17 794
8f26c9ff
DD		 795 srp_map_desc(state, 0, state->fmr_len, fmr->fmr->rkey);
796 state->npages = state->fmr_len = 0;
797 return 0;
798}
799
800static void srp_map_update_start(struct srp_map_state *state,
801 struct scatterlist *sg, int sg_index,
802 dma_addr_t dma_addr)
803{
804 state->unmapped_sg = sg;
805 state->unmapped_index = sg_index;
806 state->unmapped_addr = dma_addr;
807}
85507bcc 808
8f26c9ff
DD		 809static int srp_map_sg_entry(struct srp_map_state *state,
810 struct srp_target_port *target,
811 struct scatterlist *sg, int sg_index,
812 int use_fmr)
813{
814 struct srp_device *dev = target->srp_host->srp_dev;
815 struct ib_device *ibdev = dev->dev;
816 dma_addr_t dma_addr = ib_sg_dma_address(ibdev, sg);
817 unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
818 unsigned int len;
819 int ret;
820
821 if (!dma_len)
822 return 0;
823
824 if (use_fmr == SRP_MAP_NO_FMR) {
825 /* Once we're in direct map mode for a request, we don't
826 * go back to FMR mode, so no need to update anything
827 * other than the descriptor.
828 */
829 srp_map_desc(state, dma_addr, dma_len, target->rkey);
830 return 0;
85507bcc 831 }
f5358a17 832
8f26c9ff
DD		 833 /* If we start at an offset into the FMR page, don't merge into
834 * the current FMR. Finish it out, and use the kernel's MR for this
835 * sg entry. This is to avoid potential bugs on some SRP targets
836 * that were never quite defined, but went away when the initiator
837 * avoided using FMR on such page fragments.
838 */
839 if (dma_addr & ~dev->fmr_page_mask || dma_len > dev->fmr_max_size) {
840 ret = srp_map_finish_fmr(state, target);
841 if (ret)
842 return ret;
843
844 srp_map_desc(state, dma_addr, dma_len, target->rkey);
845 srp_map_update_start(state, NULL, 0, 0);
846 return 0;
f5358a17
RD		 847 }
848
8f26c9ff
DD		 849 /* If this is the first sg to go into the FMR, save our position.
850 * We need to know the first unmapped entry, its index, and the
851 * first unmapped address within that entry to be able to restart
852 * mapping after an error.
853 */
854 if (!state->unmapped_sg)
855 srp_map_update_start(state, sg, sg_index, dma_addr);
f5358a17 856
8f26c9ff
DD		 857 while (dma_len) {
858 if (state->npages == SRP_FMR_SIZE) {
859 ret = srp_map_finish_fmr(state, target);
860 if (ret)
861 return ret;
f5358a17 862
8f26c9ff
DD		 863 srp_map_update_start(state, sg, sg_index, dma_addr);
864 }
865
866 len = min_t(unsigned int, dma_len, dev->fmr_page_size);
f5358a17 867
8f26c9ff
DD		 868 if (!state->npages)
869 state->base_dma_addr = dma_addr;
870 state->pages[state->npages++] = dma_addr;
871 state->fmr_len += len;
872 dma_addr += len;
873 dma_len -= len;
874 }
875
876 /* If the last entry of the FMR wasn't a full page, then we need to
877 * close it out and start a new one -- we can only merge at page
878 * boundries.
879 */
880 ret = 0;
881 if (len != dev->fmr_page_size) {
882 ret = srp_map_finish_fmr(state, target);
883 if (!ret)
884 srp_map_update_start(state, NULL, 0, 0);
885 }
f5358a17
RD		 886 return ret;
887}
888
aef9ec39
RD		 889static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
890 struct srp_request *req)
891{
8f26c9ff 892 struct scatterlist *scat, *sg;
aef9ec39 893 struct srp_cmd *cmd = req->cmd->buf;
8f26c9ff 894 int i, len, nents, count, use_fmr;
85507bcc
RC		 895 struct srp_device *dev;
896 struct ib_device *ibdev;
8f26c9ff
DD		 897 struct srp_map_state state;
898 struct srp_indirect_buf *indirect_hdr;
8f26c9ff
DD		 899 u32 table_len;
900 u8 fmt;
aef9ec39 901
bb350d1d 902 if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE)
aef9ec39
RD		 903 return sizeof (struct srp_cmd);
904
905 if (scmnd->sc_data_direction != DMA_FROM_DEVICE &&
906 scmnd->sc_data_direction != DMA_TO_DEVICE) {
7aa54bd7
DD		 907 shost_printk(KERN_WARNING, target->scsi_host,
908 PFX "Unhandled data direction %d\n",
909 scmnd->sc_data_direction);
aef9ec39
RD		 910 return -EINVAL;
911 }
912
bb350d1d
FT		 913 nents = scsi_sg_count(scmnd);
914 scat = scsi_sglist(scmnd);
aef9ec39 915
05321937 916 dev = target->srp_host->srp_dev;
85507bcc
RC		 917 ibdev = dev->dev;
918
919 count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
8f26c9ff
DD		 920 if (unlikely(count == 0))
921 return -EIO;
f5358a17
RD		 922
923 fmt = SRP_DATA_DESC_DIRECT;
924 len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf);
aef9ec39 925
cf368713 926 if (count == 1) {
f5358a17
RD		 927 /*
928 * The midlayer only generated a single gather/scatter
929 * entry, or DMA mapping coalesced everything to a
930 * single entry. So a direct descriptor along with
931 * the DMA MR suffices.
932 */
cf368713 933 struct srp_direct_buf *buf = (void *) cmd->add_data;
aef9ec39 934
85507bcc 935 buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, scat));
9af76271 936 buf->key = cpu_to_be32(target->rkey);
85507bcc 937 buf->len = cpu_to_be32(ib_sg_dma_len(ibdev, scat));
8f26c9ff
DD		 938
939 req->nfmr = 0;
940 goto map_complete;
941 }
942
943 /* We have more than one scatter/gather entry, so build our indirect
944 * descriptor table, trying to merge as many entries with FMR as we
945 * can.
946 */
947 indirect_hdr = (void *) cmd->add_data;
948
c07d424d
DD		 949 ib_dma_sync_single_for_cpu(ibdev, req->indirect_dma_addr,
950 target->indirect_size, DMA_TO_DEVICE);
951
8f26c9ff 952 memset(&state, 0, sizeof(state));
c07d424d 953 state.desc = req->indirect_desc;
8f26c9ff
DD		 954 state.pages = req->map_page;
955 state.next_fmr = req->fmr_list;
956
957 use_fmr = dev->fmr_pool ? SRP_MAP_ALLOW_FMR : SRP_MAP_NO_FMR;
958
959 for_each_sg(scat, sg, count, i) {
960 if (srp_map_sg_entry(&state, target, sg, i, use_fmr)) {
961 /* FMR mapping failed, so backtrack to the first
962 * unmapped entry and continue on without using FMR.
963 */
964 dma_addr_t dma_addr;
965 unsigned int dma_len;
966
967backtrack:
968 sg = state.unmapped_sg;
969 i = state.unmapped_index;
970
971 dma_addr = ib_sg_dma_address(ibdev, sg);
972 dma_len = ib_sg_dma_len(ibdev, sg);
973 dma_len -= (state.unmapped_addr - dma_addr);
974 dma_addr = state.unmapped_addr;
975 use_fmr = SRP_MAP_NO_FMR;
976 srp_map_desc(&state, dma_addr, dma_len, target->rkey);
f5358a17 977 }
8f26c9ff 978 }
aef9ec39 979
8f26c9ff
DD		 980 if (use_fmr == SRP_MAP_ALLOW_FMR && srp_map_finish_fmr(&state, target))
981 goto backtrack;
cf368713 982
c07d424d
DD		 983 /* We've mapped the request, now pull as much of the indirect
984 * descriptor table as we can into the command buffer. If this
985 * target is not using an external indirect table, we are
986 * guaranteed to fit into the command, as the SCSI layer won't
987 * give us more S/G entries than we allow.
8f26c9ff
DD		 988 */
989 req->nfmr = state.nfmr;
990 if (state.ndesc == 1) {
991 /* FMR mapping was able to collapse this to one entry,
992 * so use a direct descriptor.
993 */
994 struct srp_direct_buf *buf = (void *) cmd->add_data;
cf368713 995
c07d424d 996 *buf = req->indirect_desc[0];
8f26c9ff 997 goto map_complete;
aef9ec39
RD		 998 }
999
c07d424d
DD		 1000 if (unlikely(target->cmd_sg_cnt < state.ndesc &&
1001 !target->allow_ext_sg)) {
1002 shost_printk(KERN_ERR, target->scsi_host,
1003 "Could not fit S/G list into SRP_CMD\n");
1004 return -EIO;
1005 }
1006
1007 count = min(state.ndesc, target->cmd_sg_cnt);
8f26c9ff
DD		 1008 table_len = state.ndesc * sizeof (struct srp_direct_buf);
1009
1010 fmt = SRP_DATA_DESC_INDIRECT;
1011 len = sizeof(struct srp_cmd) + sizeof (struct srp_indirect_buf);
c07d424d 1012 len += count * sizeof (struct srp_direct_buf);
8f26c9ff 1013
c07d424d
DD		 1014 memcpy(indirect_hdr->desc_list, req->indirect_desc,
1015 count * sizeof (struct srp_direct_buf));
8f26c9ff 1016
c07d424d 1017 indirect_hdr->table_desc.va = cpu_to_be64(req->indirect_dma_addr);
8f26c9ff
DD		 1018 indirect_hdr->table_desc.key = cpu_to_be32(target->rkey);
1019 indirect_hdr->table_desc.len = cpu_to_be32(table_len);
1020 indirect_hdr->len = cpu_to_be32(state.total_len);
1021
1022 if (scmnd->sc_data_direction == DMA_TO_DEVICE)
c07d424d 1023 cmd->data_out_desc_cnt = count;
8f26c9ff 1024 else
c07d424d
DD		 1025 cmd->data_in_desc_cnt = count;
1026
1027 ib_dma_sync_single_for_device(ibdev, req->indirect_dma_addr, table_len,
1028 DMA_TO_DEVICE);
8f26c9ff
DD		 1029
1030map_complete:
aef9ec39
RD		 1031 if (scmnd->sc_data_direction == DMA_TO_DEVICE)
1032 cmd->buf_fmt = fmt << 4;
1033 else
1034 cmd->buf_fmt = fmt;
1035
aef9ec39
RD		 1036 return len;
1037}
1038
76c75b25
BVA		 1039/*
1040 * Return an IU and possible credit to the free pool
1041 */
1042static void srp_put_tx_iu(struct srp_target_port *target, struct srp_iu *iu,
1043 enum srp_iu_type iu_type)
1044{
1045 unsigned long flags;
1046
e9684678 1047 spin_lock_irqsave(&target->lock, flags);
76c75b25
BVA		 1048 list_add(&iu->list, &target->free_tx);
1049 if (iu_type != SRP_IU_RSP)
1050 ++target->req_lim;
e9684678 1051 spin_unlock_irqrestore(&target->lock, flags);
76c75b25
BVA		 1052}
1053
05a1d750 1054/*
e9684678
BVA		 1055 * Must be called with target->lock held to protect req_lim and free_tx.
1056 * If IU is not sent, it must be returned using srp_put_tx_iu().
05a1d750
DD		 1057 *
1058 * Note:
1059 * An upper limit for the number of allocated information units for each
1060 * request type is:
1061 * - SRP_IU_CMD: SRP_CMD_SQ_SIZE, since the SCSI mid-layer never queues
1062 * more than Scsi_Host.can_queue requests.
1063 * - SRP_IU_TSK_MGMT: SRP_TSK_MGMT_SQ_SIZE.
1064 * - SRP_IU_RSP: 1, since a conforming SRP target never sends more than
1065 * one unanswered SRP request to an initiator.
1066 */
1067static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target,
1068 enum srp_iu_type iu_type)
1069{
1070 s32 rsv = (iu_type == SRP_IU_TSK_MGMT) ? 0 : SRP_TSK_MGMT_SQ_SIZE;
1071 struct srp_iu *iu;
1072
1073 srp_send_completion(target->send_cq, target);
1074
dcb4cb85 1075 if (list_empty(&target->free_tx))
05a1d750
DD		 1076 return NULL;
1077
1078 /* Initiator responses to target requests do not consume credits */
76c75b25
BVA		 1079 if (iu_type != SRP_IU_RSP) {
1080 if (target->req_lim <= rsv) {
1081 ++target->zero_req_lim;
1082 return NULL;
1083 }
1084
1085 --target->req_lim;
05a1d750
DD		 1086 }
1087
dcb4cb85 1088 iu = list_first_entry(&target->free_tx, struct srp_iu, list);
76c75b25 1089 list_del(&iu->list);
05a1d750
DD		 1090 return iu;
1091}
1092
76c75b25
BVA		 1093static int srp_post_send(struct srp_target_port *target,
1094 struct srp_iu *iu, int len)
05a1d750
DD		 1095{
1096 struct ib_sge list;
1097 struct ib_send_wr wr, *bad_wr;
05a1d750
DD		 1098
1099 list.addr = iu->dma;
1100 list.length = len;
9af76271 1101 list.lkey = target->lkey;
05a1d750
DD		 1102
1103 wr.next = NULL;
dcb4cb85 1104 wr.wr_id = (uintptr_t) iu;
05a1d750
DD		 1105 wr.sg_list = &list;
1106 wr.num_sge = 1;
1107 wr.opcode = IB_WR_SEND;
1108 wr.send_flags = IB_SEND_SIGNALED;
1109
76c75b25 1110 return ib_post_send(target->qp, &wr, &bad_wr);
05a1d750
DD		 1111}
1112
dcb4cb85 1113static int srp_post_recv(struct srp_target_port *target, struct srp_iu *iu)
c996bb47 1114{
c996bb47 1115 struct ib_recv_wr wr, *bad_wr;
dcb4cb85 1116 struct ib_sge list;
c996bb47
BVA		 1117
1118 list.addr = iu->dma;
1119 list.length = iu->size;
9af76271 1120 list.lkey = target->lkey;
c996bb47
BVA		 1121
1122 wr.next = NULL;
dcb4cb85 1123 wr.wr_id = (uintptr_t) iu;
c996bb47
BVA		 1124 wr.sg_list = &list;
1125 wr.num_sge = 1;
1126
dcb4cb85 1127 return ib_post_recv(target->qp, &wr, &bad_wr);
c996bb47
BVA		 1128}
1129
aef9ec39
RD		 1130static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
1131{
1132 struct srp_request *req;
1133 struct scsi_cmnd *scmnd;
1134 unsigned long flags;
aef9ec39 1135
aef9ec39 1136 if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) {
e9684678 1137 spin_lock_irqsave(&target->lock, flags);
94a9174c 1138 target->req_lim += be32_to_cpu(rsp->req_lim_delta);
e9684678 1139 spin_unlock_irqrestore(&target->lock, flags);
94a9174c 1140
f8b6e31e
DD		 1141 target->tsk_mgmt_status = -1;
1142 if (be32_to_cpu(rsp->resp_data_len) >= 4)
1143 target->tsk_mgmt_status = rsp->data[3];
1144 complete(&target->tsk_mgmt_done);
aef9ec39 1145 } else {
f8b6e31e 1146 req = &target->req_ring[rsp->tag];
22032991
BVA		 1147 scmnd = srp_claim_req(target, req, NULL);
1148 if (!scmnd) {
7aa54bd7
DD		 1149 shost_printk(KERN_ERR, target->scsi_host,
1150 "Null scmnd for RSP w/tag %016llx\n",
1151 (unsigned long long) rsp->tag);
22032991
BVA		 1152
1153 spin_lock_irqsave(&target->lock, flags);
1154 target->req_lim += be32_to_cpu(rsp->req_lim_delta);
1155 spin_unlock_irqrestore(&target->lock, flags);
1156
1157 return;
1158 }
aef9ec39
RD		 1159 scmnd->result = rsp->status;
1160
1161 if (rsp->flags & SRP_RSP_FLAG_SNSVALID) {
1162 memcpy(scmnd->sense_buffer, rsp->data +
1163 be32_to_cpu(rsp->resp_data_len),
1164 min_t(int, be32_to_cpu(rsp->sense_data_len),
1165 SCSI_SENSE_BUFFERSIZE));
1166 }
1167
1168 if (rsp->flags & (SRP_RSP_FLAG_DOOVER | SRP_RSP_FLAG_DOUNDER))
bb350d1d 1169 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_out_res_cnt));
aef9ec39 1170 else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER))
bb350d1d 1171 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt));
aef9ec39 1172
22032991
BVA		 1173 srp_free_req(target, req, scmnd,
1174 be32_to_cpu(rsp->req_lim_delta));
1175
f8b6e31e
DD		 1176 scmnd->host_scribble = NULL;
1177 scmnd->scsi_done(scmnd);
aef9ec39 1178 }
aef9ec39
RD		 1179}
1180
bb12588a
DD		 1181static int srp_response_common(struct srp_target_port *target, s32 req_delta,
1182 void *rsp, int len)
1183{
76c75b25 1184 struct ib_device *dev = target->srp_host->srp_dev->dev;
bb12588a
DD		 1185 unsigned long flags;
1186 struct srp_iu *iu;
76c75b25 1187 int err;
bb12588a 1188
e9684678 1189 spin_lock_irqsave(&target->lock, flags);
bb12588a 1190 target->req_lim += req_delta;
bb12588a 1191 iu = __srp_get_tx_iu(target, SRP_IU_RSP);
e9684678 1192 spin_unlock_irqrestore(&target->lock, flags);
76c75b25 1193
bb12588a
DD		 1194 if (!iu) {
1195 shost_printk(KERN_ERR, target->scsi_host, PFX
1196 "no IU available to send response\n");
76c75b25 1197 return 1;
bb12588a
DD		 1198 }
1199
1200 ib_dma_sync_single_for_cpu(dev, iu->dma, len, DMA_TO_DEVICE);
1201 memcpy(iu->buf, rsp, len);
1202 ib_dma_sync_single_for_device(dev, iu->dma, len, DMA_TO_DEVICE);
1203
76c75b25
BVA		 1204 err = srp_post_send(target, iu, len);
1205 if (err) {
bb12588a
DD		 1206 shost_printk(KERN_ERR, target->scsi_host, PFX
1207 "unable to post response: %d\n", err);
76c75b25
BVA		 1208 srp_put_tx_iu(target, iu, SRP_IU_RSP);
1209 }
bb12588a 1210
bb12588a
DD		 1211 return err;
1212}
1213
1214static void srp_process_cred_req(struct srp_target_port *target,
1215 struct srp_cred_req *req)
1216{
1217 struct srp_cred_rsp rsp = {
1218 .opcode = SRP_CRED_RSP,
1219 .tag = req->tag,
1220 };
1221 s32 delta = be32_to_cpu(req->req_lim_delta);
1222
1223 if (srp_response_common(target, delta, &rsp, sizeof rsp))
1224 shost_printk(KERN_ERR, target->scsi_host, PFX
1225 "problems processing SRP_CRED_REQ\n");
1226}
1227
1228static void srp_process_aer_req(struct srp_target_port *target,
1229 struct srp_aer_req *req)
1230{
1231 struct srp_aer_rsp rsp = {
1232 .opcode = SRP_AER_RSP,
1233 .tag = req->tag,
1234 };
1235 s32 delta = be32_to_cpu(req->req_lim_delta);
1236
1237 shost_printk(KERN_ERR, target->scsi_host, PFX
1238 "ignoring AER for LUN %llu\n", be64_to_cpu(req->lun));
1239
1240 if (srp_response_common(target, delta, &rsp, sizeof rsp))
1241 shost_printk(KERN_ERR, target->scsi_host, PFX
1242 "problems processing SRP_AER_REQ\n");
1243}
1244
aef9ec39
RD		 1245static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
1246{
dcb4cb85 1247 struct ib_device *dev = target->srp_host->srp_dev->dev;
737b94eb 1248 struct srp_iu *iu = (struct srp_iu *) (uintptr_t) wc->wr_id;
c996bb47 1249 int res;
aef9ec39
RD		 1250 u8 opcode;
1251
85507bcc
RC		 1252 ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len,
1253 DMA_FROM_DEVICE);
aef9ec39
RD		 1254
1255 opcode = *(u8 *) iu->buf;
1256
1257 if (0) {
7aa54bd7
DD		 1258 shost_printk(KERN_ERR, target->scsi_host,
1259 PFX "recv completion, opcode 0x%02x\n", opcode);
7a700811
BVA		 1260 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 8, 1,
1261 iu->buf, wc->byte_len, true);
aef9ec39
RD		 1262 }
1263
1264 switch (opcode) {
1265 case SRP_RSP:
1266 srp_process_rsp(target, iu->buf);
1267 break;
1268
bb12588a
DD		 1269 case SRP_CRED_REQ:
1270 srp_process_cred_req(target, iu->buf);
1271 break;
1272
1273 case SRP_AER_REQ:
1274 srp_process_aer_req(target, iu->buf);
1275 break;
1276
aef9ec39
RD		 1277 case SRP_T_LOGOUT:
1278 /* XXX Handle target logout */
7aa54bd7
DD		 1279 shost_printk(KERN_WARNING, target->scsi_host,
1280 PFX "Got target logout request\n");
aef9ec39
RD		 1281 break;
1282
1283 default:
7aa54bd7
DD		 1284 shost_printk(KERN_WARNING, target->scsi_host,
1285 PFX "Unhandled SRP opcode 0x%02x\n", opcode);
aef9ec39
RD		 1286 break;
1287 }
1288
85507bcc
RC		 1289 ib_dma_sync_single_for_device(dev, iu->dma, target->max_ti_iu_len,
1290 DMA_FROM_DEVICE);
c996bb47 1291
dcb4cb85 1292 res = srp_post_recv(target, iu);
c996bb47
BVA		 1293 if (res != 0)
1294 shost_printk(KERN_ERR, target->scsi_host,
1295 PFX "Recv failed with error code %d\n", res);
aef9ec39
RD		 1296}
1297
948d1e88
BVA		 1298static void srp_handle_qp_err(enum ib_wc_status wc_status,
1299 enum ib_wc_opcode wc_opcode,
1300 struct srp_target_port *target)
1301{
294c875a 1302 if (target->connected && !target->qp_in_error) {
4f0af697
BVA		 1303 shost_printk(KERN_ERR, target->scsi_host,
1304 PFX "failed %s status %d\n",
1305 wc_opcode & IB_WC_RECV ? "receive" : "send",
1306 wc_status);
1307 }
948d1e88
BVA		 1308 target->qp_in_error = true;
1309}
1310
9c03dc9f 1311static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
aef9ec39
RD		 1312{
1313 struct srp_target_port *target = target_ptr;
1314 struct ib_wc wc;
aef9ec39
RD		 1315
1316 ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
1317 while (ib_poll_cq(cq, 1, &wc) > 0) {
948d1e88
BVA		 1318 if (likely(wc.status == IB_WC_SUCCESS)) {
1319 srp_handle_recv(target, &wc);
1320 } else {
1321 srp_handle_qp_err(wc.status, wc.opcode, target);
aef9ec39 1322 }
9c03dc9f
BVA		 1323 }
1324}
1325
1326static void srp_send_completion(struct ib_cq *cq, void *target_ptr)
1327{
1328 struct srp_target_port *target = target_ptr;
1329 struct ib_wc wc;
dcb4cb85 1330 struct srp_iu *iu;
9c03dc9f
BVA		 1331
1332 while (ib_poll_cq(cq, 1, &wc) > 0) {
948d1e88
BVA		 1333 if (likely(wc.status == IB_WC_SUCCESS)) {
1334 iu = (struct srp_iu *) (uintptr_t) wc.wr_id;
1335 list_add(&iu->list, &target->free_tx);
1336 } else {
1337 srp_handle_qp_err(wc.status, wc.opcode, target);
9c03dc9f 1338 }
aef9ec39
RD		 1339 }
1340}
1341
76c75b25 1342static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
aef9ec39 1343{
76c75b25 1344 struct srp_target_port *target = host_to_target(shost);
aef9ec39
RD		 1345 struct srp_request *req;
1346 struct srp_iu *iu;
1347 struct srp_cmd *cmd;
85507bcc 1348 struct ib_device *dev;
76c75b25 1349 unsigned long flags;
aef9ec39
RD		 1350 int len;
1351
e9684678 1352 spin_lock_irqsave(&target->lock, flags);
bb12588a 1353 iu = __srp_get_tx_iu(target, SRP_IU_CMD);
aef9ec39 1354 if (!iu)
695b8349
BVA		 1355 goto err_unlock;
1356
1357 req = list_first_entry(&target->free_reqs, struct srp_request, list);
1358 list_del(&req->list);
1359 spin_unlock_irqrestore(&target->lock, flags);
aef9ec39 1360
05321937 1361 dev = target->srp_host->srp_dev->dev;
49248644 1362 ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_iu_len,
85507bcc 1363 DMA_TO_DEVICE);
aef9ec39 1364
aef9ec39 1365 scmnd->result = 0;
f8b6e31e 1366 scmnd->host_scribble = (void *) req;
aef9ec39
RD		 1367
1368 cmd = iu->buf;
1369 memset(cmd, 0, sizeof *cmd);
1370
1371 cmd->opcode = SRP_CMD;
1372 cmd->lun = cpu_to_be64((u64) scmnd->device->lun << 48);
d945e1df 1373 cmd->tag = req->index;
aef9ec39
RD		 1374 memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
1375
aef9ec39
RD		 1376 req->scmnd = scmnd;
1377 req->cmd = iu;
aef9ec39
RD		 1378
1379 len = srp_map_data(scmnd, target, req);
1380 if (len < 0) {
7aa54bd7
DD		 1381 shost_printk(KERN_ERR, target->scsi_host,
1382 PFX "Failed to map data\n");
76c75b25 1383 goto err_iu;
aef9ec39
RD		 1384 }
1385
49248644 1386 ib_dma_sync_single_for_device(dev, iu->dma, target->max_iu_len,
85507bcc 1387 DMA_TO_DEVICE);
aef9ec39 1388
76c75b25 1389 if (srp_post_send(target, iu, len)) {
7aa54bd7 1390 shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n");
aef9ec39
RD		 1391 goto err_unmap;
1392 }
1393
aef9ec39
RD		 1394 return 0;
1395
1396err_unmap:
1397 srp_unmap_data(scmnd, target, req);
1398
76c75b25
BVA		 1399err_iu:
1400 srp_put_tx_iu(target, iu, SRP_IU_CMD);
1401
e9684678 1402 spin_lock_irqsave(&target->lock, flags);
76c75b25 1403 list_add(&req->list, &target->free_reqs);
695b8349
BVA		 1404
1405err_unlock:
e9684678 1406 spin_unlock_irqrestore(&target->lock, flags);
76c75b25 1407
aef9ec39
RD		 1408 return SCSI_MLQUEUE_HOST_BUSY;
1409}
1410
1411static int srp_alloc_iu_bufs(struct srp_target_port *target)
1412{
1413 int i;
1414
1415 for (i = 0; i < SRP_RQ_SIZE; ++i) {
1416 target->rx_ring[i] = srp_alloc_iu(target->srp_host,
1417 target->max_ti_iu_len,
1418 GFP_KERNEL, DMA_FROM_DEVICE);
1419 if (!target->rx_ring[i])
1420 goto err;
1421 }
1422
dd5e6e38 1423 for (i = 0; i < SRP_SQ_SIZE; ++i) {
aef9ec39 1424 target->tx_ring[i] = srp_alloc_iu(target->srp_host,
49248644 1425 target->max_iu_len,
aef9ec39
RD		 1426 GFP_KERNEL, DMA_TO_DEVICE);
1427 if (!target->tx_ring[i])
1428 goto err;
dcb4cb85
BVA		 1429
1430 list_add(&target->tx_ring[i]->list, &target->free_tx);
aef9ec39
RD		 1431 }
1432
1433 return 0;
1434
1435err:
1436 for (i = 0; i < SRP_RQ_SIZE; ++i) {
1437 srp_free_iu(target->srp_host, target->rx_ring[i]);
1438 target->rx_ring[i] = NULL;
1439 }
1440
dd5e6e38 1441 for (i = 0; i < SRP_SQ_SIZE; ++i) {
aef9ec39
RD		 1442 srp_free_iu(target->srp_host, target->tx_ring[i]);
1443 target->tx_ring[i] = NULL;
1444 }
1445
1446 return -ENOMEM;
1447}
1448
c9b03c1a
BVA		 1449static uint32_t srp_compute_rq_tmo(struct ib_qp_attr *qp_attr, int attr_mask)
1450{
1451 uint64_t T_tr_ns, max_compl_time_ms;
1452 uint32_t rq_tmo_jiffies;
1453
1454 /*
1455 * According to section 11.2.4.2 in the IBTA spec (Modify Queue Pair,
1456 * table 91), both the QP timeout and the retry count have to be set
1457 * for RC QP's during the RTR to RTS transition.
1458 */
1459 WARN_ON_ONCE((attr_mask & (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)) !=
1460 (IB_QP_TIMEOUT | IB_QP_RETRY_CNT));
1461
1462 /*
1463 * Set target->rq_tmo_jiffies to one second more than the largest time
1464 * it can take before an error completion is generated. See also
1465 * C9-140..142 in the IBTA spec for more information about how to
1466 * convert the QP Local ACK Timeout value to nanoseconds.
1467 */
1468 T_tr_ns = 4096 * (1ULL << qp_attr->timeout);
1469 max_compl_time_ms = qp_attr->retry_cnt * 4 * T_tr_ns;
1470 do_div(max_compl_time_ms, NSEC_PER_MSEC);
1471 rq_tmo_jiffies = msecs_to_jiffies(max_compl_time_ms + 1000);
1472
1473 return rq_tmo_jiffies;
1474}
1475
961e0be8
DD		 1476static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
1477 struct srp_login_rsp *lrsp,
1478 struct srp_target_port *target)
1479{
1480 struct ib_qp_attr *qp_attr = NULL;
1481 int attr_mask = 0;
1482 int ret;
1483 int i;
1484
1485 if (lrsp->opcode == SRP_LOGIN_RSP) {
1486 target->max_ti_iu_len = be32_to_cpu(lrsp->max_ti_iu_len);
1487 target->req_lim = be32_to_cpu(lrsp->req_lim_delta);
1488
1489 /*
1490 * Reserve credits for task management so we don't
1491 * bounce requests back to the SCSI mid-layer.
1492 */
1493 target->scsi_host->can_queue
1494 = min(target->req_lim - SRP_TSK_MGMT_SQ_SIZE,
1495 target->scsi_host->can_queue);
1496 } else {
1497 shost_printk(KERN_WARNING, target->scsi_host,
1498 PFX "Unhandled RSP opcode %#x\n", lrsp->opcode);
1499 ret = -ECONNRESET;
1500 goto error;
1501 }
1502
1503 if (!target->rx_ring[0]) {
1504 ret = srp_alloc_iu_bufs(target);
1505 if (ret)
1506 goto error;
1507 }
1508
1509 ret = -ENOMEM;
1510 qp_attr = kmalloc(sizeof *qp_attr, GFP_KERNEL);
1511 if (!qp_attr)
1512 goto error;
1513
1514 qp_attr->qp_state = IB_QPS_RTR;
1515 ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
1516 if (ret)
1517 goto error_free;
1518
1519 ret = ib_modify_qp(target->qp, qp_attr, attr_mask);
1520 if (ret)
1521 goto error_free;
1522
1523 for (i = 0; i < SRP_RQ_SIZE; i++) {
1524 struct srp_iu *iu = target->rx_ring[i];
1525 ret = srp_post_recv(target, iu);
1526 if (ret)
1527 goto error_free;
1528 }
1529
1530 qp_attr->qp_state = IB_QPS_RTS;
1531 ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
1532 if (ret)
1533 goto error_free;
1534
c9b03c1a
BVA		 1535 target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask);
1536
961e0be8
DD		 1537 ret = ib_modify_qp(target->qp, qp_attr, attr_mask);
1538 if (ret)
1539 goto error_free;
1540
1541 ret = ib_send_cm_rtu(cm_id, NULL, 0);
1542
1543error_free:
1544 kfree(qp_attr);
1545
1546error:
1547 target->status = ret;
1548}
1549
aef9ec39
RD		 1550static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
1551 struct ib_cm_event *event,
1552 struct srp_target_port *target)
1553{
7aa54bd7 1554 struct Scsi_Host *shost = target->scsi_host;
aef9ec39
RD		 1555 struct ib_class_port_info *cpi;
1556 int opcode;
1557
1558 switch (event->param.rej_rcvd.reason) {
1559 case IB_CM_REJ_PORT_CM_REDIRECT:
1560 cpi = event->param.rej_rcvd.ari;
1561 target->path.dlid = cpi->redirect_lid;
1562 target->path.pkey = cpi->redirect_pkey;
1563 cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff;
1564 memcpy(target->path.dgid.raw, cpi->redirect_gid, 16);
1565
1566 target->status = target->path.dlid ?
1567 SRP_DLID_REDIRECT : SRP_PORT_REDIRECT;
1568 break;
1569
1570 case IB_CM_REJ_PORT_REDIRECT:
5d7cbfd6 1571 if (srp_target_is_topspin(target)) {
aef9ec39
RD		 1572 /*
1573 * Topspin/Cisco SRP gateways incorrectly send
1574 * reject reason code 25 when they mean 24
1575 * (port redirect).
1576 */
1577 memcpy(target->path.dgid.raw,
1578 event->param.rej_rcvd.ari, 16);
1579
7aa54bd7
DD		 1580 shost_printk(KERN_DEBUG, shost,
1581 PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n",
1582 (unsigned long long) be64_to_cpu(target->path.dgid.global.subnet_prefix),
1583 (unsigned long long) be64_to_cpu(target->path.dgid.global.interface_id));
aef9ec39
RD		 1584
1585 target->status = SRP_PORT_REDIRECT;
1586 } else {
7aa54bd7
DD		 1587 shost_printk(KERN_WARNING, shost,
1588 " REJ reason: IB_CM_REJ_PORT_REDIRECT\n");
aef9ec39
RD		 1589 target->status = -ECONNRESET;
1590 }
1591 break;
1592
1593 case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
7aa54bd7
DD		 1594 shost_printk(KERN_WARNING, shost,
1595 " REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n");
aef9ec39
RD		 1596 target->status = -ECONNRESET;
1597 break;
1598
1599 case IB_CM_REJ_CONSUMER_DEFINED:
1600 opcode = *(u8 *) event->private_data;
1601 if (opcode == SRP_LOGIN_REJ) {
1602 struct srp_login_rej *rej = event->private_data;
1603 u32 reason = be32_to_cpu(rej->reason);
1604
1605 if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE)
7aa54bd7
DD		 1606 shost_printk(KERN_WARNING, shost,
1607 PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n");
aef9ec39 1608 else
7aa54bd7
DD		 1609 shost_printk(KERN_WARNING, shost,
1610 PFX "SRP LOGIN REJECTED, reason 0x%08x\n", reason);
aef9ec39 1611 } else
7aa54bd7
DD		 1612 shost_printk(KERN_WARNING, shost,
1613 " REJ reason: IB_CM_REJ_CONSUMER_DEFINED,"
1614 " opcode 0x%02x\n", opcode);
aef9ec39
RD		 1615 target->status = -ECONNRESET;
1616 break;
1617
9fe4bcf4
DD		 1618 case IB_CM_REJ_STALE_CONN:
1619 shost_printk(KERN_WARNING, shost, " REJ reason: stale connection\n");
1620 target->status = SRP_STALE_CONN;
1621 break;
1622
aef9ec39 1623 default:
7aa54bd7
DD		 1624 shost_printk(KERN_WARNING, shost, " REJ reason 0x%x\n",
1625 event->param.rej_rcvd.reason);
aef9ec39
RD		 1626 target->status = -ECONNRESET;
1627 }
1628}
1629
1630static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
1631{
1632 struct srp_target_port *target = cm_id->context;
aef9ec39 1633 int comp = 0;
aef9ec39
RD		 1634
1635 switch (event->event) {
1636 case IB_CM_REQ_ERROR:
7aa54bd7
DD		 1637 shost_printk(KERN_DEBUG, target->scsi_host,
1638 PFX "Sending CM REQ failed\n");
aef9ec39
RD		 1639 comp = 1;
1640 target->status = -ECONNRESET;
1641 break;
1642
1643 case IB_CM_REP_RECEIVED:
1644 comp = 1;
961e0be8 1645 srp_cm_rep_handler(cm_id, event->private_data, target);
aef9ec39
RD		 1646 break;
1647
1648 case IB_CM_REJ_RECEIVED:
7aa54bd7 1649 shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n");
aef9ec39
RD		 1650 comp = 1;
1651
1652 srp_cm_rej_handler(cm_id, event, target);
1653 break;
1654
b7ac4ab4 1655 case IB_CM_DREQ_RECEIVED:
7aa54bd7
DD		 1656 shost_printk(KERN_WARNING, target->scsi_host,
1657 PFX "DREQ received - connection closed\n");
294c875a 1658 srp_change_conn_state(target, false);
b7ac4ab4 1659 if (ib_send_cm_drep(cm_id, NULL, 0))
7aa54bd7
DD		 1660 shost_printk(KERN_ERR, target->scsi_host,
1661 PFX "Sending CM DREP failed\n");
aef9ec39
RD		 1662 break;
1663
1664 case IB_CM_TIMEWAIT_EXIT:
7aa54bd7
DD		 1665 shost_printk(KERN_ERR, target->scsi_host,
1666 PFX "connection closed\n");
aef9ec39
RD		 1667
1668 comp = 1;
1669 target->status = 0;
1670 break;
1671
b7ac4ab4
IR		 1672 case IB_CM_MRA_RECEIVED:
1673 case IB_CM_DREQ_ERROR:
1674 case IB_CM_DREP_RECEIVED:
1675 break;
1676
aef9ec39 1677 default:
7aa54bd7
DD		 1678 shost_printk(KERN_WARNING, target->scsi_host,
1679 PFX "Unhandled CM event %d\n", event->event);
aef9ec39
RD		 1680 break;
1681 }
1682
1683 if (comp)
1684 complete(&target->done);
1685
aef9ec39
RD		 1686 return 0;
1687}
1688
d945e1df 1689static int srp_send_tsk_mgmt(struct srp_target_port *target,
f8b6e31e 1690 u64 req_tag, unsigned int lun, u8 func)
aef9ec39 1691{
19081f31 1692 struct ib_device *dev = target->srp_host->srp_dev->dev;
aef9ec39
RD		 1693 struct srp_iu *iu;
1694 struct srp_tsk_mgmt *tsk_mgmt;
aef9ec39 1695
f8b6e31e 1696 init_completion(&target->tsk_mgmt_done);
aef9ec39 1697
e9684678 1698 spin_lock_irq(&target->lock);
bb12588a 1699 iu = __srp_get_tx_iu(target, SRP_IU_TSK_MGMT);
e9684678 1700 spin_unlock_irq(&target->lock);
76c75b25 1701
aef9ec39 1702 if (!iu)
76c75b25 1703 return -1;
aef9ec39 1704
19081f31
DD		 1705 ib_dma_sync_single_for_cpu(dev, iu->dma, sizeof *tsk_mgmt,
1706 DMA_TO_DEVICE);
aef9ec39
RD		 1707 tsk_mgmt = iu->buf;
1708 memset(tsk_mgmt, 0, sizeof *tsk_mgmt);
1709
1710 tsk_mgmt->opcode = SRP_TSK_MGMT;
f8b6e31e
DD		 1711 tsk_mgmt->lun = cpu_to_be64((u64) lun << 48);
1712 tsk_mgmt->tag = req_tag | SRP_TAG_TSK_MGMT;
aef9ec39 1713 tsk_mgmt->tsk_mgmt_func = func;
f8b6e31e 1714 tsk_mgmt->task_tag = req_tag;
aef9ec39 1715
19081f31
DD		 1716 ib_dma_sync_single_for_device(dev, iu->dma, sizeof *tsk_mgmt,
1717 DMA_TO_DEVICE);
76c75b25
BVA		 1718 if (srp_post_send(target, iu, sizeof *tsk_mgmt)) {
1719 srp_put_tx_iu(target, iu, SRP_IU_TSK_MGMT);
1720 return -1;
1721 }
d945e1df 1722
f8b6e31e 1723 if (!wait_for_completion_timeout(&target->tsk_mgmt_done,
aef9ec39 1724 msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS)))
d945e1df 1725 return -1;
aef9ec39 1726
d945e1df 1727 return 0;
d945e1df
RD		 1728}
1729
aef9ec39
RD		 1730static int srp_abort(struct scsi_cmnd *scmnd)
1731{
d945e1df 1732 struct srp_target_port *target = host_to_target(scmnd->device->host);
f8b6e31e 1733 struct srp_request *req = (struct srp_request *) scmnd->host_scribble;
d945e1df 1734
7aa54bd7 1735 shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
aef9ec39 1736
22032991 1737 if (!req || target->qp_in_error || !srp_claim_req(target, req, scmnd))
d945e1df 1738 return FAILED;
22032991
BVA		 1739 srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
1740 SRP_TSK_ABORT_TASK);
1741 srp_free_req(target, req, scmnd, 0);
1742 scmnd->result = DID_ABORT << 16;
d8536670 1743 scmnd->scsi_done(scmnd);
d945e1df 1744
22032991 1745 return SUCCESS;
aef9ec39
RD		 1746}
1747
1748static int srp_reset_device(struct scsi_cmnd *scmnd)
1749{
d945e1df 1750 struct srp_target_port *target = host_to_target(scmnd->device->host);
536ae14e 1751 int i;
d945e1df 1752
7aa54bd7 1753 shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
aef9ec39 1754
1033ff67
IR		 1755 if (target->qp_in_error)
1756 return FAILED;
f8b6e31e
DD		 1757 if (srp_send_tsk_mgmt(target, SRP_TAG_NO_REQ, scmnd->device->lun,
1758 SRP_TSK_LUN_RESET))
d945e1df 1759 return FAILED;
f8b6e31e 1760 if (target->tsk_mgmt_status)
d945e1df
RD		 1761 return FAILED;
1762
536ae14e
BVA		 1763 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
1764 struct srp_request *req = &target->req_ring[i];
f8b6e31e 1765 if (req->scmnd && req->scmnd->device == scmnd->device)
526b4caa 1766 srp_reset_req(target, req);
536ae14e 1767 }
d945e1df 1768
d945e1df 1769 return SUCCESS;
aef9ec39
RD		 1770}
1771
1772static int srp_reset_host(struct scsi_cmnd *scmnd)
1773{
1774 struct srp_target_port *target = host_to_target(scmnd->device->host);
1775 int ret = FAILED;
1776
7aa54bd7 1777 shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n");
aef9ec39
RD		 1778
1779 if (!srp_reconnect_target(target))
1780 ret = SUCCESS;
1781
1782 return ret;
1783}
1784
c9b03c1a
BVA		 1785static int srp_slave_configure(struct scsi_device *sdev)
1786{
1787 struct Scsi_Host *shost = sdev->host;
1788 struct srp_target_port *target = host_to_target(shost);
1789 struct request_queue *q = sdev->request_queue;
1790 unsigned long timeout;
1791
1792 if (sdev->type == TYPE_DISK) {
1793 timeout = max_t(unsigned, 30 * HZ, target->rq_tmo_jiffies);
1794 blk_queue_rq_timeout(q, timeout);
1795 }
1796
1797 return 0;
1798}
1799
ee959b00
TJ		 1800static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
1801 char *buf)
6ecb0c84 1802{
ee959b00 1803 struct srp_target_port *target = host_to_target(class_to_shost(dev));
6ecb0c84 1804
6ecb0c84
RD		 1805 return sprintf(buf, "0x%016llx\n",
1806 (unsigned long long) be64_to_cpu(target->id_ext));
1807}
1808
ee959b00
TJ		 1809static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
1810 char *buf)
6ecb0c84 1811{
ee959b00 1812 struct srp_target_port *target = host_to_target(class_to_shost(dev));
6ecb0c84 1813
6ecb0c84
RD		 1814 return sprintf(buf, "0x%016llx\n",
1815 (unsigned long long) be64_to_cpu(target->ioc_guid));
1816}
1817
ee959b00
TJ		 1818static ssize_t show_service_id(struct device *dev,
1819 struct device_attribute *attr, char *buf)
6ecb0c84 1820{
ee959b00 1821 struct srp_target_port *target = host_to_target(class_to_shost(dev));
6ecb0c84 1822
6ecb0c84
RD		 1823 return sprintf(buf, "0x%016llx\n",
1824 (unsigned long long) be64_to_cpu(target->service_id));
1825}
1826
ee959b00
TJ		 1827static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
1828 char *buf)
6ecb0c84 1829{
ee959b00 1830 struct srp_target_port *target = host_to_target(class_to_shost(dev));
6ecb0c84 1831
6ecb0c84
RD		 1832 return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
1833}
1834
ee959b00
TJ		 1835static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
1836 char *buf)
6ecb0c84 1837{
ee959b00 1838 struct srp_target_port *target = host_to_target(class_to_shost(dev));
6ecb0c84 1839
5b095d98 1840 return sprintf(buf, "%pI6\n", target->path.dgid.raw);
6ecb0c84
RD		 1841}
1842
ee959b00
TJ		 1843static ssize_t show_orig_dgid(struct device *dev,
1844 struct device_attribute *attr, char *buf)
3633b3d0 1845{
ee959b00 1846 struct srp_target_port *target = host_to_target(class_to_shost(dev));
3633b3d0 1847
5b095d98 1848 return sprintf(buf, "%pI6\n", target->orig_dgid);
3633b3d0
IR		 1849}
1850
89de7486
BVA		 1851static ssize_t show_req_lim(struct device *dev,
1852 struct device_attribute *attr, char *buf)
1853{
1854 struct srp_target_port *target = host_to_target(class_to_shost(dev));
1855
89de7486
BVA		 1856 return sprintf(buf, "%d\n", target->req_lim);
1857}
1858
ee959b00
TJ		 1859static ssize_t show_zero_req_lim(struct device *dev,
1860 struct device_attribute *attr, char *buf)
6bfa24fa 1861{
ee959b00 1862 struct srp_target_port *target = host_to_target(class_to_shost(dev));
6bfa24fa 1863
6bfa24fa
RD		 1864 return sprintf(buf, "%d\n", target->zero_req_lim);
1865}
1866
ee959b00
TJ		 1867static ssize_t show_local_ib_port(struct device *dev,
1868 struct device_attribute *attr, char *buf)
ded7f1a1 1869{
ee959b00 1870 struct srp_target_port *target = host_to_target(class_to_shost(dev));
ded7f1a1
IR		 1871
1872 return sprintf(buf, "%d\n", target->srp_host->port);
1873}
1874
ee959b00
TJ		 1875static ssize_t show_local_ib_device(struct device *dev,
1876 struct device_attribute *attr, char *buf)
ded7f1a1 1877{
ee959b00 1878 struct srp_target_port *target = host_to_target(class_to_shost(dev));
ded7f1a1 1879
05321937 1880 return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
ded7f1a1
IR		 1881}
1882
49248644
DD		 1883static ssize_t show_cmd_sg_entries(struct device *dev,
1884 struct device_attribute *attr, char *buf)
1885{
1886 struct srp_target_port *target = host_to_target(class_to_shost(dev));
1887
1888 return sprintf(buf, "%u\n", target->cmd_sg_cnt);
1889}
1890
c07d424d
DD		 1891static ssize_t show_allow_ext_sg(struct device *dev,
1892 struct device_attribute *attr, char *buf)
1893{
1894 struct srp_target_port *target = host_to_target(class_to_shost(dev));
1895
1896 return sprintf(buf, "%s\n", target->allow_ext_sg ? "true" : "false");
1897}
1898
ee959b00
TJ		 1899static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL);
1900static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL);
1901static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL);
1902static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
1903static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL);
1904static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL);
89de7486 1905static DEVICE_ATTR(req_lim, S_IRUGO, show_req_lim, NULL);
ee959b00
TJ		 1906static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL);
1907static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL);
1908static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
49248644 1909static DEVICE_ATTR(cmd_sg_entries, S_IRUGO, show_cmd_sg_entries, NULL);
c07d424d 1910static DEVICE_ATTR(allow_ext_sg, S_IRUGO, show_allow_ext_sg, NULL);
ee959b00
TJ		 1911
1912static struct device_attribute *srp_host_attrs[] = {
1913 &dev_attr_id_ext,
1914 &dev_attr_ioc_guid,
1915 &dev_attr_service_id,
1916 &dev_attr_pkey,
1917 &dev_attr_dgid,
1918 &dev_attr_orig_dgid,
89de7486 1919 &dev_attr_req_lim,
ee959b00
TJ		 1920 &dev_attr_zero_req_lim,
1921 &dev_attr_local_ib_port,
1922 &dev_attr_local_ib_device,
49248644 1923 &dev_attr_cmd_sg_entries,
c07d424d 1924 &dev_attr_allow_ext_sg,
6ecb0c84
RD		 1925 NULL
1926};
1927
aef9ec39
RD		 1928static struct scsi_host_template srp_template = {
1929 .module = THIS_MODULE,
b7f008fd
RD		 1930 .name = "InfiniBand SRP initiator",
1931 .proc_name = DRV_NAME,
c9b03c1a 1932 .slave_configure = srp_slave_configure,
aef9ec39
RD		 1933 .info = srp_target_info,
1934 .queuecommand = srp_queuecommand,
1935 .eh_abort_handler = srp_abort,
1936 .eh_device_reset_handler = srp_reset_device,
1937 .eh_host_reset_handler = srp_reset_host,
49248644 1938 .sg_tablesize = SRP_DEF_SG_TABLESIZE,
dd5e6e38 1939 .can_queue = SRP_CMD_SQ_SIZE,
aef9ec39 1940 .this_id = -1,
dd5e6e38 1941 .cmd_per_lun = SRP_CMD_SQ_SIZE,
6ecb0c84
RD		 1942 .use_clustering = ENABLE_CLUSTERING,
1943 .shost_attrs = srp_host_attrs
aef9ec39
RD		 1944};
1945
1946static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
1947{
3236822b
FT		 1948 struct srp_rport_identifiers ids;
1949 struct srp_rport *rport;
1950
aef9ec39
RD		 1951 sprintf(target->target_name, "SRP.T10:%016llX",
1952 (unsigned long long) be64_to_cpu(target->id_ext));
1953
05321937 1954 if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
aef9ec39
RD		 1955 return -ENODEV;
1956
3236822b
FT		 1957 memcpy(ids.port_id, &target->id_ext, 8);
1958 memcpy(ids.port_id + 8, &target->ioc_guid, 8);
aebd5e47 1959 ids.roles = SRP_RPORT_ROLE_TARGET;
3236822b
FT		 1960 rport = srp_rport_add(target->scsi_host, &ids);
1961 if (IS_ERR(rport)) {
1962 scsi_remove_host(target->scsi_host);
1963 return PTR_ERR(rport);
1964 }
1965
b3589fd4 1966 spin_lock(&host->target_lock);
aef9ec39 1967 list_add_tail(&target->list, &host->target_list);
b3589fd4 1968 spin_unlock(&host->target_lock);
aef9ec39
RD		 1969
1970 target->state = SRP_TARGET_LIVE;
294c875a 1971 target->connected = false;
aef9ec39 1972
aef9ec39 1973 scsi_scan_target(&target->scsi_host->shost_gendev,
1962a4a1 1974 0, target->scsi_id, SCAN_WILD_CARD, 0);
aef9ec39
RD		 1975
1976 return 0;
1977}
1978
ee959b00 1979static void srp_release_dev(struct device *dev)
aef9ec39
RD		 1980{
1981 struct srp_host *host =
ee959b00 1982 container_of(dev, struct srp_host, dev);
aef9ec39
RD		 1983
1984 complete(&host->released);
1985}
1986
1987static struct class srp_class = {
1988 .name = "infiniband_srp",
ee959b00 1989 .dev_release = srp_release_dev
aef9ec39
RD		 1990};
1991
1992/*
1993 * Target ports are added by writing
1994 *
1995 * id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,dgid=<dest GID>,
1996 * pkey=<P_Key>,service_id=<service ID>
1997 *
1998 * to the add_target sysfs attribute.
1999 */
2000enum {
2001 SRP_OPT_ERR = 0,
2002 SRP_OPT_ID_EXT = 1 << 0,
2003 SRP_OPT_IOC_GUID = 1 << 1,
2004 SRP_OPT_DGID = 1 << 2,
2005 SRP_OPT_PKEY = 1 << 3,
2006 SRP_OPT_SERVICE_ID = 1 << 4,
2007 SRP_OPT_MAX_SECT = 1 << 5,
52fb2b50 2008 SRP_OPT_MAX_CMD_PER_LUN = 1 << 6,
0c0450db 2009 SRP_OPT_IO_CLASS = 1 << 7,
01cb9bcb 2010 SRP_OPT_INITIATOR_EXT = 1 << 8,
49248644 2011 SRP_OPT_CMD_SG_ENTRIES = 1 << 9,
c07d424d
DD		 2012 SRP_OPT_ALLOW_EXT_SG = 1 << 10,
2013 SRP_OPT_SG_TABLESIZE = 1 << 11,
aef9ec39
RD		 2014 SRP_OPT_ALL = (SRP_OPT_ID_EXT |
2015 SRP_OPT_IOC_GUID |
2016 SRP_OPT_DGID |
2017 SRP_OPT_PKEY |
2018 SRP_OPT_SERVICE_ID),
2019};
2020
a447c093 2021static const match_table_t srp_opt_tokens = {
52fb2b50
VP		 2022 { SRP_OPT_ID_EXT, "id_ext=%s" },
2023 { SRP_OPT_IOC_GUID, "ioc_guid=%s" },
2024 { SRP_OPT_DGID, "dgid=%s" },
2025 { SRP_OPT_PKEY, "pkey=%x" },
2026 { SRP_OPT_SERVICE_ID, "service_id=%s" },
2027 { SRP_OPT_MAX_SECT, "max_sect=%d" },
2028 { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d" },
0c0450db 2029 { SRP_OPT_IO_CLASS, "io_class=%x" },
01cb9bcb 2030 { SRP_OPT_INITIATOR_EXT, "initiator_ext=%s" },
49248644 2031 { SRP_OPT_CMD_SG_ENTRIES, "cmd_sg_entries=%u" },
c07d424d
DD		 2032 { SRP_OPT_ALLOW_EXT_SG, "allow_ext_sg=%u" },
2033 { SRP_OPT_SG_TABLESIZE, "sg_tablesize=%u" },
52fb2b50 2034 { SRP_OPT_ERR, NULL }
aef9ec39
RD		 2035};
2036
2037static int srp_parse_options(const char *buf, struct srp_target_port *target)
2038{
2039 char *options, *sep_opt;
2040 char *p;
2041 char dgid[3];
2042 substring_t args[MAX_OPT_ARGS];
2043 int opt_mask = 0;
2044 int token;
2045 int ret = -EINVAL;
2046 int i;
2047
2048 options = kstrdup(buf, GFP_KERNEL);
2049 if (!options)
2050 return -ENOMEM;
2051
2052 sep_opt = options;
2053 while ((p = strsep(&sep_opt, ",")) != NULL) {
2054 if (!*p)
2055 continue;
2056
2057 token = match_token(p, srp_opt_tokens, args);
2058 opt_mask |= token;
2059
2060 switch (token) {
2061 case SRP_OPT_ID_EXT:
2062 p = match_strdup(args);
a20f3a6d
IR		 2063 if (!p) {
2064 ret = -ENOMEM;
2065 goto out;
2066 }
aef9ec39
RD		 2067 target->id_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
2068 kfree(p);
2069 break;
2070
2071 case SRP_OPT_IOC_GUID:
2072 p = match_strdup(args);
a20f3a6d
IR		 2073 if (!p) {
2074 ret = -ENOMEM;
2075 goto out;
2076 }
aef9ec39
RD		 2077 target->ioc_guid = cpu_to_be64(simple_strtoull(p, NULL, 16));
2078 kfree(p);
2079 break;
2080
2081 case SRP_OPT_DGID:
2082 p = match_strdup(args);
a20f3a6d
IR		 2083 if (!p) {
2084 ret = -ENOMEM;
2085 goto out;
2086 }
aef9ec39 2087 if (strlen(p) != 32) {
e0bda7d8 2088 pr_warn("bad dest GID parameter '%s'\n", p);
ce1823f0 2089 kfree(p);
aef9ec39
RD		 2090 goto out;
2091 }
2092
2093 for (i = 0; i < 16; ++i) {
2094 strlcpy(dgid, p + i * 2, 3);
2095 target->path.dgid.raw[i] = simple_strtoul(dgid, NULL, 16);
2096 }
bf17c1c7 2097 kfree(p);
3633b3d0 2098 memcpy(target->orig_dgid, target->path.dgid.raw, 16);
aef9ec39
RD		 2099 break;
2100
2101 case SRP_OPT_PKEY:
2102 if (match_hex(args, &token)) {
e0bda7d8 2103 pr_warn("bad P_Key parameter '%s'\n", p);
aef9ec39
RD		 2104 goto out;
2105 }
2106 target->path.pkey = cpu_to_be16(token);
2107 break;
2108
2109 case SRP_OPT_SERVICE_ID:
2110 p = match_strdup(args);
a20f3a6d
IR		 2111 if (!p) {
2112 ret = -ENOMEM;
2113 goto out;
2114 }
aef9ec39 2115 target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16));
247e020e 2116 target->path.service_id = target->service_id;
aef9ec39
RD		 2117 kfree(p);
2118 break;
2119
2120 case SRP_OPT_MAX_SECT:
2121 if (match_int(args, &token)) {
e0bda7d8 2122 pr_warn("bad max sect parameter '%s'\n", p);
aef9ec39
RD		 2123 goto out;
2124 }
2125 target->scsi_host->max_sectors = token;
2126 break;
2127
52fb2b50
VP		 2128 case SRP_OPT_MAX_CMD_PER_LUN:
2129 if (match_int(args, &token)) {
e0bda7d8
BVA		 2130 pr_warn("bad max cmd_per_lun parameter '%s'\n",
2131 p);
52fb2b50
VP		 2132 goto out;
2133 }
dd5e6e38 2134 target->scsi_host->cmd_per_lun = min(token, SRP_CMD_SQ_SIZE);
52fb2b50
VP		 2135 break;
2136
0c0450db
R		 2137 case SRP_OPT_IO_CLASS:
2138 if (match_hex(args, &token)) {
e0bda7d8 2139 pr_warn("bad IO class parameter '%s'\n", p);
0c0450db
R		 2140 goto out;
2141 }
2142 if (token != SRP_REV10_IB_IO_CLASS &&
2143 token != SRP_REV16A_IB_IO_CLASS) {
e0bda7d8
BVA		 2144 pr_warn("unknown IO class parameter value %x specified (use %x or %x).\n",
2145 token, SRP_REV10_IB_IO_CLASS,
2146 SRP_REV16A_IB_IO_CLASS);
0c0450db
R		 2147 goto out;
2148 }
2149 target->io_class = token;
2150 break;
2151
01cb9bcb
IR		 2152 case SRP_OPT_INITIATOR_EXT:
2153 p = match_strdup(args);
a20f3a6d
IR		 2154 if (!p) {
2155 ret = -ENOMEM;
2156 goto out;
2157 }
01cb9bcb
IR		 2158 target->initiator_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
2159 kfree(p);
2160 break;
2161
49248644
DD		 2162 case SRP_OPT_CMD_SG_ENTRIES:
2163 if (match_int(args, &token) || token < 1 || token > 255) {
e0bda7d8
BVA		 2164 pr_warn("bad max cmd_sg_entries parameter '%s'\n",
2165 p);
49248644
DD		 2166 goto out;
2167 }
2168 target->cmd_sg_cnt = token;
2169 break;
2170
c07d424d
DD		 2171 case SRP_OPT_ALLOW_EXT_SG:
2172 if (match_int(args, &token)) {
e0bda7d8 2173 pr_warn("bad allow_ext_sg parameter '%s'\n", p);
c07d424d
DD		 2174 goto out;
2175 }
2176 target->allow_ext_sg = !!token;
2177 break;
2178
2179 case SRP_OPT_SG_TABLESIZE:
2180 if (match_int(args, &token) || token < 1 ||
2181 token > SCSI_MAX_SG_CHAIN_SEGMENTS) {
e0bda7d8
BVA		 2182 pr_warn("bad max sg_tablesize parameter '%s'\n",
2183 p);
c07d424d
DD		 2184 goto out;
2185 }
2186 target->sg_tablesize = token;
2187 break;
2188
aef9ec39 2189 default:
e0bda7d8
BVA		 2190 pr_warn("unknown parameter or missing value '%s' in target creation request\n",
2191 p);
aef9ec39
RD		 2192 goto out;
2193 }
2194 }
2195
2196 if ((opt_mask & SRP_OPT_ALL) == SRP_OPT_ALL)
2197 ret = 0;
2198 else
2199 for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i)
2200 if ((srp_opt_tokens[i].token & SRP_OPT_ALL) &&
2201 !(srp_opt_tokens[i].token & opt_mask))
e0bda7d8
BVA		 2202 pr_warn("target creation request is missing parameter '%s'\n",
2203 srp_opt_tokens[i].pattern);
aef9ec39
RD		 2204
2205out:
2206 kfree(options);
2207 return ret;
2208}
2209
ee959b00
TJ		 2210static ssize_t srp_create_target(struct device *dev,
2211 struct device_attribute *attr,
aef9ec39
RD		 2212 const char *buf, size_t count)
2213{
2214 struct srp_host *host =
ee959b00 2215 container_of(dev, struct srp_host, dev);
aef9ec39
RD		 2216 struct Scsi_Host *target_host;
2217 struct srp_target_port *target;
c07d424d
DD		 2218 struct ib_device *ibdev = host->srp_dev->dev;
2219 dma_addr_t dma_addr;
8f26c9ff 2220 int i, ret;
aef9ec39
RD		 2221
2222 target_host = scsi_host_alloc(&srp_template,
2223 sizeof (struct srp_target_port));
2224 if (!target_host)
2225 return -ENOMEM;
2226
49248644 2227 target_host->transportt = ib_srp_transport_template;
fd1b6c4a
BVA		 2228 target_host->max_channel = 0;
2229 target_host->max_id = 1;
3c8edf0e
AR		 2230 target_host->max_lun = SRP_MAX_LUN;
2231 target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb;
5f068992 2232
aef9ec39 2233 target = host_to_target(target_host);
aef9ec39 2234
49248644
DD		 2235 target->io_class = SRP_REV16A_IB_IO_CLASS;
2236 target->scsi_host = target_host;
2237 target->srp_host = host;
2238 target->lkey = host->srp_dev->mr->lkey;
2239 target->rkey = host->srp_dev->mr->rkey;
2240 target->cmd_sg_cnt = cmd_sg_entries;
c07d424d
DD		 2241 target->sg_tablesize = indirect_sg_entries ? : cmd_sg_entries;
2242 target->allow_ext_sg = allow_ext_sg;
aef9ec39 2243
aef9ec39
RD		 2244 ret = srp_parse_options(buf, target);
2245 if (ret)
2246 goto err;
2247
c07d424d
DD		 2248 if (!host->srp_dev->fmr_pool && !target->allow_ext_sg &&
2249 target->cmd_sg_cnt < target->sg_tablesize) {
e0bda7d8 2250 pr_warn("No FMR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
c07d424d
DD		 2251 target->sg_tablesize = target->cmd_sg_cnt;
2252 }
2253
2254 target_host->sg_tablesize = target->sg_tablesize;
2255 target->indirect_size = target->sg_tablesize *
2256 sizeof (struct srp_direct_buf);
49248644
DD		 2257 target->max_iu_len = sizeof (struct srp_cmd) +
2258 sizeof (struct srp_indirect_buf) +
2259 target->cmd_sg_cnt * sizeof (struct srp_direct_buf);
2260
8f26c9ff
DD		 2261 spin_lock_init(&target->lock);
2262 INIT_LIST_HEAD(&target->free_tx);
2263 INIT_LIST_HEAD(&target->free_reqs);
2264 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
2265 struct srp_request *req = &target->req_ring[i];
2266
2267 req->fmr_list = kmalloc(target->cmd_sg_cnt * sizeof (void *),
2268 GFP_KERNEL);
2269 req->map_page = kmalloc(SRP_FMR_SIZE * sizeof (void *),
2270 GFP_KERNEL);
c07d424d
DD		 2271 req->indirect_desc = kmalloc(target->indirect_size, GFP_KERNEL);
2272 if (!req->fmr_list || !req->map_page || !req->indirect_desc)
8f26c9ff
DD		 2273 goto err_free_mem;
2274
c07d424d
DD		 2275 dma_addr = ib_dma_map_single(ibdev, req->indirect_desc,
2276 target->indirect_size,
2277 DMA_TO_DEVICE);
2278 if (ib_dma_mapping_error(ibdev, dma_addr))
2279 goto err_free_mem;
2280
2281 req->indirect_dma_addr = dma_addr;
8f26c9ff
DD		 2282 req->index = i;
2283 list_add_tail(&req->list, &target->free_reqs);
2284 }
2285
c07d424d 2286 ib_query_gid(ibdev, host->port, 0, &target->path.sgid);
aef9ec39 2287
7aa54bd7
DD		 2288 shost_printk(KERN_DEBUG, target->scsi_host, PFX
2289 "new target: id_ext %016llx ioc_guid %016llx pkey %04x "
5b095d98 2290 "service_id %016llx dgid %pI6\n",
aef9ec39
RD		 2291 (unsigned long long) be64_to_cpu(target->id_ext),
2292 (unsigned long long) be64_to_cpu(target->ioc_guid),
2293 be16_to_cpu(target->path.pkey),
2294 (unsigned long long) be64_to_cpu(target->service_id),
8867cd7c 2295 target->path.dgid.raw);
aef9ec39
RD		 2296
2297 ret = srp_create_target_ib(target);
2298 if (ret)
8f26c9ff 2299 goto err_free_mem;
aef9ec39 2300
9fe4bcf4
DD		 2301 ret = srp_new_cm_id(target);
2302 if (ret)
8f26c9ff 2303 goto err_free_ib;
aef9ec39
RD		 2304
2305 ret = srp_connect_target(target);
2306 if (ret) {
7aa54bd7
DD		 2307 shost_printk(KERN_ERR, target->scsi_host,
2308 PFX "Connection failed\n");
aef9ec39
RD		 2309 goto err_cm_id;
2310 }
2311
2312 ret = srp_add_target(host, target);
2313 if (ret)
2314 goto err_disconnect;
2315
2316 return count;
2317
2318err_disconnect:
2319 srp_disconnect_target(target);
2320
2321err_cm_id:
2322 ib_destroy_cm_id(target->cm_id);
2323
8f26c9ff 2324err_free_ib:
aef9ec39
RD		 2325 srp_free_target_ib(target);
2326
8f26c9ff
DD		 2327err_free_mem:
2328 srp_free_req_data(target);
2329
aef9ec39
RD		 2330err:
2331 scsi_host_put(target_host);
2332
2333 return ret;
2334}
2335
ee959b00 2336static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
aef9ec39 2337
ee959b00
TJ		 2338static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
2339 char *buf)
aef9ec39 2340{
ee959b00 2341 struct srp_host *host = container_of(dev, struct srp_host, dev);
aef9ec39 2342
05321937 2343 return sprintf(buf, "%s\n", host->srp_dev->dev->name);
aef9ec39
RD		 2344}
2345
ee959b00 2346static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
aef9ec39 2347
ee959b00
TJ		 2348static ssize_t show_port(struct device *dev, struct device_attribute *attr,
2349 char *buf)
aef9ec39 2350{
ee959b00 2351 struct srp_host *host = container_of(dev, struct srp_host, dev);
aef9ec39
RD		 2352
2353 return sprintf(buf, "%d\n", host->port);
2354}
2355
ee959b00 2356static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
aef9ec39 2357
f5358a17 2358static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
aef9ec39
RD		 2359{
2360 struct srp_host *host;
2361
2362 host = kzalloc(sizeof *host, GFP_KERNEL);
2363 if (!host)
2364 return NULL;
2365
2366 INIT_LIST_HEAD(&host->target_list);
b3589fd4 2367 spin_lock_init(&host->target_lock);
aef9ec39 2368 init_completion(&host->released);
05321937 2369 host->srp_dev = device;
aef9ec39
RD		 2370 host->port = port;
2371
ee959b00
TJ		 2372 host->dev.class = &srp_class;
2373 host->dev.parent = device->dev->dma_device;
d927e38c 2374 dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port);
aef9ec39 2375
ee959b00 2376 if (device_register(&host->dev))
f5358a17 2377 goto free_host;
ee959b00 2378 if (device_create_file(&host->dev, &dev_attr_add_target))
aef9ec39 2379 goto err_class;
ee959b00 2380 if (device_create_file(&host->dev, &dev_attr_ibdev))
aef9ec39 2381 goto err_class;
ee959b00 2382 if (device_create_file(&host->dev, &dev_attr_port))
aef9ec39
RD		 2383 goto err_class;
2384
2385 return host;
2386
2387err_class:
ee959b00 2388 device_unregister(&host->dev);
aef9ec39 2389
f5358a17 2390free_host:
aef9ec39
RD		 2391 kfree(host);
2392
2393 return NULL;
2394}
2395
2396static void srp_add_one(struct ib_device *device)
2397{
f5358a17
RD		 2398 struct srp_device *srp_dev;
2399 struct ib_device_attr *dev_attr;
2400 struct ib_fmr_pool_param fmr_param;
aef9ec39 2401 struct srp_host *host;
be8b9814 2402 int max_pages_per_fmr, fmr_page_shift, s, e, p;
aef9ec39 2403
f5358a17
RD		 2404 dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL);
2405 if (!dev_attr)
cf311cd4 2406 return;
aef9ec39 2407
f5358a17 2408 if (ib_query_device(device, dev_attr)) {
e0bda7d8 2409 pr_warn("Query device failed for %s\n", device->name);
f5358a17
RD		 2410 goto free_attr;
2411 }
2412
2413 srp_dev = kmalloc(sizeof *srp_dev, GFP_KERNEL);
2414 if (!srp_dev)
2415 goto free_attr;
2416
2417 /*
2418 * Use the smallest page size supported by the HCA, down to a
8f26c9ff
DD		 2419 * minimum of 4096 bytes. We're unlikely to build large sglists
2420 * out of smaller entries.
f5358a17 2421 */
8f26c9ff
DD		 2422 fmr_page_shift = max(12, ffs(dev_attr->page_size_cap) - 1);
2423 srp_dev->fmr_page_size = 1 << fmr_page_shift;
2424 srp_dev->fmr_page_mask = ~((u64) srp_dev->fmr_page_size - 1);
2425 srp_dev->fmr_max_size = srp_dev->fmr_page_size * SRP_FMR_SIZE;
f5358a17
RD		 2426
2427 INIT_LIST_HEAD(&srp_dev->dev_list);
2428
2429 srp_dev->dev = device;
2430 srp_dev->pd = ib_alloc_pd(device);
2431 if (IS_ERR(srp_dev->pd))
2432 goto free_dev;
2433
2434 srp_dev->mr = ib_get_dma_mr(srp_dev->pd,
2435 IB_ACCESS_LOCAL_WRITE |
2436 IB_ACCESS_REMOTE_READ |
2437 IB_ACCESS_REMOTE_WRITE);
2438 if (IS_ERR(srp_dev->mr))
2439 goto err_pd;
2440
be8b9814
DD		 2441 for (max_pages_per_fmr = SRP_FMR_SIZE;
2442 max_pages_per_fmr >= SRP_FMR_MIN_SIZE;
2443 max_pages_per_fmr /= 2, srp_dev->fmr_max_size /= 2) {
2444 memset(&fmr_param, 0, sizeof fmr_param);
2445 fmr_param.pool_size = SRP_FMR_POOL_SIZE;
2446 fmr_param.dirty_watermark = SRP_FMR_DIRTY_SIZE;
2447 fmr_param.cache = 1;
2448 fmr_param.max_pages_per_fmr = max_pages_per_fmr;
2449 fmr_param.page_shift = fmr_page_shift;
2450 fmr_param.access = (IB_ACCESS_LOCAL_WRITE |
2451 IB_ACCESS_REMOTE_WRITE |
2452 IB_ACCESS_REMOTE_READ);
2453
2454 srp_dev->fmr_pool = ib_create_fmr_pool(srp_dev->pd, &fmr_param);
2455 if (!IS_ERR(srp_dev->fmr_pool))
2456 break;
2457 }
2458
f5358a17
RD		 2459 if (IS_ERR(srp_dev->fmr_pool))
2460 srp_dev->fmr_pool = NULL;
aef9ec39 2461
07ebafba 2462 if (device->node_type == RDMA_NODE_IB_SWITCH) {
aef9ec39
RD		 2463 s = 0;
2464 e = 0;
2465 } else {
2466 s = 1;
2467 e = device->phys_port_cnt;
2468 }
2469
2470 for (p = s; p <= e; ++p) {
f5358a17 2471 host = srp_add_port(srp_dev, p);
aef9ec39 2472 if (host)
f5358a17 2473 list_add_tail(&host->list, &srp_dev->dev_list);
aef9ec39
RD		 2474 }
2475
f5358a17
RD		 2476 ib_set_client_data(device, &srp_client, srp_dev);
2477
2478 goto free_attr;
2479
2480err_pd:
2481 ib_dealloc_pd(srp_dev->pd);
2482
2483free_dev:
2484 kfree(srp_dev);
2485
2486free_attr:
2487 kfree(dev_attr);
aef9ec39
RD		 2488}
2489
2490static void srp_remove_one(struct ib_device *device)
2491{
f5358a17 2492 struct srp_device *srp_dev;
aef9ec39
RD		 2493 struct srp_host *host, *tmp_host;
2494 LIST_HEAD(target_list);
2495 struct srp_target_port *target, *tmp_target;
aef9ec39 2496
f5358a17 2497 srp_dev = ib_get_client_data(device, &srp_client);
aef9ec39 2498
f5358a17 2499 list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
ee959b00 2500 device_unregister(&host->dev);
aef9ec39
RD		 2501 /*
2502 * Wait for the sysfs entry to go away, so that no new
2503 * target ports can be created.
2504 */
2505 wait_for_completion(&host->released);
2506
2507 /*
2508 * Mark all target ports as removed, so we stop queueing
2509 * commands and don't try to reconnect.
2510 */
b3589fd4 2511 spin_lock(&host->target_lock);
549c5fc2 2512 list_for_each_entry(target, &host->target_list, list) {
e9684678 2513 spin_lock_irq(&target->lock);
0c5b3952 2514 target->state = SRP_TARGET_REMOVED;
e9684678 2515 spin_unlock_irq(&target->lock);
aef9ec39 2516 }
b3589fd4 2517 spin_unlock(&host->target_lock);
aef9ec39
RD		 2518
2519 /*
2520 * Wait for any reconnection tasks that may have
2521 * started before we marked our target ports as
2522 * removed, and any target port removal tasks.
2523 */
f0626710 2524 flush_workqueue(ib_wq);
aef9ec39
RD		 2525
2526 list_for_each_entry_safe(target, tmp_target,
2527 &host->target_list, list) {
683b159a 2528 srp_del_scsi_host_attr(target->scsi_host);
b0e47c8b 2529 srp_remove_host(target->scsi_host);
ad696989 2530 scsi_remove_host(target->scsi_host);
aef9ec39
RD		 2531 srp_disconnect_target(target);
2532 ib_destroy_cm_id(target->cm_id);
2533 srp_free_target_ib(target);
8f26c9ff 2534 srp_free_req_data(target);
aef9ec39
RD		 2535 scsi_host_put(target->scsi_host);
2536 }
2537
aef9ec39
RD		 2538 kfree(host);
2539 }
2540
f5358a17
RD		 2541 if (srp_dev->fmr_pool)
2542 ib_destroy_fmr_pool(srp_dev->fmr_pool);
2543 ib_dereg_mr(srp_dev->mr);
2544 ib_dealloc_pd(srp_dev->pd);
2545
2546 kfree(srp_dev);
aef9ec39
RD		 2547}
2548
3236822b
FT		 2549static struct srp_function_template ib_srp_transport_functions = {
2550};
2551
aef9ec39
RD		 2552static int __init srp_init_module(void)
2553{
2554 int ret;
2555
dcb4cb85 2556 BUILD_BUG_ON(FIELD_SIZEOF(struct ib_wc, wr_id) < sizeof(void *));
dd5e6e38 2557
49248644 2558 if (srp_sg_tablesize) {
e0bda7d8 2559 pr_warn("srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
49248644
DD		 2560 if (!cmd_sg_entries)
2561 cmd_sg_entries = srp_sg_tablesize;
2562 }
2563
2564 if (!cmd_sg_entries)
2565 cmd_sg_entries = SRP_DEF_SG_TABLESIZE;
2566
2567 if (cmd_sg_entries > 255) {
e0bda7d8 2568 pr_warn("Clamping cmd_sg_entries to 255\n");
49248644 2569 cmd_sg_entries = 255;
1e89a194
DD		 2570 }
2571
c07d424d
DD		 2572 if (!indirect_sg_entries)
2573 indirect_sg_entries = cmd_sg_entries;
2574 else if (indirect_sg_entries < cmd_sg_entries) {
e0bda7d8
BVA		 2575 pr_warn("Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n",
2576 cmd_sg_entries);
c07d424d
DD		 2577 indirect_sg_entries = cmd_sg_entries;
2578 }
2579
3236822b
FT		 2580 ib_srp_transport_template =
2581 srp_attach_transport(&ib_srp_transport_functions);
2582 if (!ib_srp_transport_template)
2583 return -ENOMEM;
2584
aef9ec39
RD		 2585 ret = class_register(&srp_class);
2586 if (ret) {
e0bda7d8 2587 pr_err("couldn't register class infiniband_srp\n");
3236822b 2588 srp_release_transport(ib_srp_transport_template);
aef9ec39
RD		 2589 return ret;
2590 }
2591
c1a0b23b
MT		 2592 ib_sa_register_client(&srp_sa_client);
2593
aef9ec39
RD		 2594 ret = ib_register_client(&srp_client);
2595 if (ret) {
e0bda7d8 2596 pr_err("couldn't register IB client\n");
3236822b 2597 srp_release_transport(ib_srp_transport_template);
c1a0b23b 2598 ib_sa_unregister_client(&srp_sa_client);
aef9ec39
RD		 2599 class_unregister(&srp_class);
2600 return ret;
2601 }
2602
2603 return 0;
2604}
2605
2606static void __exit srp_cleanup_module(void)
2607{
2608 ib_unregister_client(&srp_client);
c1a0b23b 2609 ib_sa_unregister_client(&srp_sa_client);
aef9ec39 2610 class_unregister(&srp_class);
3236822b 2611 srp_release_transport(ib_srp_transport_template);
aef9ec39
RD		 2612}
2613
2614module_init(srp_init_module);
2615module_exit(srp_cleanup_module);
ubuntu-bionic-kernel mirror