Fixed a memory leak in an error path.
[mirror/scst/.git] / srpt / src / ib_srpt.c
1 /*
2  * Copyright (c) 2006 - 2009 Mellanox Technology Inc.  All rights reserved.
3  * Copyright (C) 2008 Vladislav Bolkhovitin <vst@vlnb.net>
4  * Copyright (C) 2008 - 2010 Bart Van Assche <bart.vanassche@gmail.com>
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  *
34  */
35
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/err.h>
40 #include <linux/ctype.h>
41 #include <linux/string.h>
42 #include <linux/delay.h>
43 #include <asm/atomic.h>
44 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
45 #include <linux/proc_fs.h>
46 #include <linux/seq_file.h>
47 #endif
48 #include "ib_srpt.h"
49 #define LOG_PREFIX "ib_srpt" /* Prefix for SCST tracing macros. */
50 #include "scst_debug.h"
51
52 #define CONFIG_SCST_PROC
53
54 /* Name of this kernel module. */
55 #define DRV_NAME                "ib_srpt"
56 #define DRV_VERSION             "1.0.1"
57 #define DRV_RELDATE             "July 10, 2008"
58 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
59 /* Flags to be used in SCST debug tracing statements. */
60 #define DEFAULT_SRPT_TRACE_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR \
61                                   | TRACE_MGMT | TRACE_SPECIAL)
62 /* Name of the entry that will be created under /proc/scsi_tgt/ib_srpt. */
63 #define SRPT_PROC_TRACE_LEVEL_NAME      "trace_level"
64 #endif
65
66 #define MELLANOX_SRPT_ID_STRING "SCST SRP target"
67
68 MODULE_AUTHOR("Vu Pham");
69 MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol target "
70                    "v" DRV_VERSION " (" DRV_RELDATE ")");
71 MODULE_LICENSE("Dual BSD/GPL");
72
73
74 /*
75  * Global Variables
76  */
77
78 static u64 srpt_service_guid;
79 /* List of srpt_device structures. */
80 static atomic_t srpt_device_count;
81 static DECLARE_WAIT_QUEUE_HEAD(ioctx_list_waitQ);
82 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
83 static unsigned long trace_flag = DEFAULT_SRPT_TRACE_FLAGS;
84 module_param(trace_flag, long, 0644);
85 MODULE_PARM_DESC(trace_flag,
86                  "Trace flags for the ib_srpt kernel module.");
87 #endif
88 #if defined(CONFIG_SCST_DEBUG)
89 static unsigned long interrupt_processing_delay_in_us;
90 module_param(interrupt_processing_delay_in_us, long, 0744);
91 MODULE_PARM_DESC(interrupt_processing_delay_in_us,
92                  "CQ completion handler interrupt delay in microseconds.");
93 #endif
94
95 static int thread;
96 module_param(thread, int, 0444);
97 MODULE_PARM_DESC(thread,
98                  "Execute SCSI commands in thread context. Defaults to zero,"
99                  " i.e. soft IRQ whenever possible.");
100
101 static unsigned srp_max_rdma_size = DEFAULT_MAX_RDMA_SIZE;
102 module_param(srp_max_rdma_size, int, 0744);
103 MODULE_PARM_DESC(srp_max_rdma_size,
104                  "Maximum size of SRP RDMA transfers for new connections.");
105
106 static unsigned srp_max_message_size = DEFAULT_MAX_MESSAGE_SIZE;
107 module_param(srp_max_message_size, int, 0444);
108 MODULE_PARM_DESC(srp_max_message_size,
109                  "Maximum size of SRP control messages in bytes.");
110
111 static int use_port_guid_in_session_name;
112 module_param(use_port_guid_in_session_name, bool, 0444);
113 MODULE_PARM_DESC(use_port_guid_in_session_name,
114                  "Use target port ID in the SCST session name such that"
115                  " redundant paths between multiport systems can be masked.");
116
117 static void srpt_add_one(struct ib_device *device);
118 static void srpt_remove_one(struct ib_device *device);
119 static void srpt_unregister_mad_agent(struct srpt_device *sdev);
120 #ifdef CONFIG_SCST_PROC
121 static void srpt_unregister_procfs_entry(struct scst_tgt_template *tgt);
122 #endif /*CONFIG_SCST_PROC*/
123 static void srpt_unmap_sg_to_ib_sge(struct srpt_rdma_ch *ch,
124                                     struct srpt_ioctx *ioctx);
125 static void srpt_release_channel(struct scst_session *scst_sess);
126
127 static struct ib_client srpt_client = {
128         .name = DRV_NAME,
129         .add = srpt_add_one,
130         .remove = srpt_remove_one
131 };
132
133 /**
134  * Atomically test and set the channel state.
135  * @ch: RDMA channel.
136  * @old: channel state to compare with.
137  * @new: state to change the channel state to if the current state matches the
138  *       argument 'old'.
139  *
140  * Returns the previous channel state.
141  */
142 static enum rdma_ch_state
143 srpt_test_and_set_channel_state(struct srpt_rdma_ch *ch,
144                                 enum rdma_ch_state old,
145                                 enum rdma_ch_state new)
146 {
147         return atomic_cmpxchg(&ch->state, old, new);
148 }
149
150 /*
151  * Callback function called by the InfiniBand core when an asynchronous IB
152  * event occurs. This callback may occur in interrupt context. See also
153  * section 11.5.2, Set Asynchronous Event Handler in the InfiniBand
154  * Architecture Specification.
155  */
156 static void srpt_event_handler(struct ib_event_handler *handler,
157                                struct ib_event *event)
158 {
159         struct srpt_device *sdev;
160         struct srpt_port *sport;
161
162         TRACE_ENTRY();
163
164         sdev = ib_get_client_data(event->device, &srpt_client);
165         if (!sdev || sdev->device != event->device)
166                 return;
167
168         TRACE_DBG("ASYNC event= %d on device= %s",
169                   event->event, sdev->device->name);
170
171         switch (event->event) {
172         case IB_EVENT_PORT_ERR:
173                 if (event->element.port_num <= sdev->device->phys_port_cnt) {
174                         sport = &sdev->port[event->element.port_num - 1];
175                         sport->lid = 0;
176                         sport->sm_lid = 0;
177                 }
178                 break;
179         case IB_EVENT_PORT_ACTIVE:
180         case IB_EVENT_LID_CHANGE:
181         case IB_EVENT_PKEY_CHANGE:
182         case IB_EVENT_SM_CHANGE:
183         case IB_EVENT_CLIENT_REREGISTER:
184                 /*
185                  * Refresh port data asynchronously. Note: it is safe to call
186                  * schedule_work() even if &sport->work is already on the
187                  * global workqueue because schedule_work() tests for the
188                  * work_pending() condition before adding &sport->work to the
189                  * global work queue.
190                  */
191                 if (event->element.port_num <= sdev->device->phys_port_cnt) {
192                         sport = &sdev->port[event->element.port_num - 1];
193                         if (!sport->lid && !sport->sm_lid)
194                                 schedule_work(&sport->work);
195                 }
196                 break;
197         default:
198                 PRINT_ERROR("received unrecognized IB event %d", event->event);
199                 break;
200         }
201
202         TRACE_EXIT();
203 }
204
205 /*
206  * Callback function called by the InfiniBand core for SRQ (shared receive
207  * queue) events.
208  */
209 static void srpt_srq_event(struct ib_event *event, void *ctx)
210 {
211         PRINT_INFO("SRQ event %d", event->event);
212 }
213
214 /*
215  * Callback function called by the InfiniBand core for QP (queue pair) events.
216  */
217 static void srpt_qp_event(struct ib_event *event, struct srpt_rdma_ch *ch)
218 {
219         TRACE_DBG("QP event %d on cm_id=%p sess_name=%s state=%d",
220                   event->event, ch->cm_id, ch->sess_name,
221                   atomic_read(&ch->state));
222
223         switch (event->event) {
224         case IB_EVENT_COMM_EST:
225 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20) || defined(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19)
226                 ib_cm_notify(ch->cm_id, event->event);
227 #else
228                 /* Vanilla 2.6.19 kernel (or before) without OFED. */
229                 PRINT_ERROR("%s", "how to perform ib_cm_notify() on a"
230                             " vanilla 2.6.18 kernel ???");
231 #endif
232                 break;
233         case IB_EVENT_QP_LAST_WQE_REACHED:
234                 if (srpt_test_and_set_channel_state(ch, RDMA_CHANNEL_LIVE,
235                         RDMA_CHANNEL_DISCONNECTING) == RDMA_CHANNEL_LIVE) {
236                         PRINT_INFO("disconnected session %s.", ch->sess_name);
237                         ib_send_cm_dreq(ch->cm_id, NULL, 0);
238                 }
239                 break;
240         default:
241                 PRINT_ERROR("received unrecognized IB QP event %d",
242                             event->event);
243                 break;
244         }
245 }
246
247 /*
248  * Helper function for filling in an InfiniBand IOUnitInfo structure. Copies
249  * the lowest four bits of value in element slot of the array of four bit
250  * elements called c_list (controller list). The index slot is one-based.
251  *
252  * @pre 1 <= slot && 0 <= value && value < 16
253  */
254 static void srpt_set_ioc(u8 *c_list, u32 slot, u8 value)
255 {
256         u16 id;
257         u8 tmp;
258
259         id = (slot - 1) / 2;
260         if (slot & 0x1) {
261                 tmp = c_list[id] & 0xf;
262                 c_list[id] = (value << 4) | tmp;
263         } else {
264                 tmp = c_list[id] & 0xf0;
265                 c_list[id] = (value & 0xf) | tmp;
266         }
267 }
268
269 /*
270  * Write InfiniBand ClassPortInfo to mad. See also section 16.3.3.1
271  * ClassPortInfo in the InfiniBand Architecture Specification.
272  */
273 static void srpt_get_class_port_info(struct ib_dm_mad *mad)
274 {
275         struct ib_class_port_info *cif;
276
277         cif = (struct ib_class_port_info *)mad->data;
278         memset(cif, 0, sizeof *cif);
279         cif->base_version = 1;
280         cif->class_version = 1;
281         cif->resp_time_value = 20;
282
283         mad->mad_hdr.status = 0;
284 }
285
286 /*
287  * Write IOUnitInfo to mad. See also section 16.3.3.3 IOUnitInfo in the
288  * InfiniBand Architecture Specification. See also section B.7,
289  * table B.6 in the T10 SRP r16a document.
290  */
291 static void srpt_get_iou(struct ib_dm_mad *mad)
292 {
293         struct ib_dm_iou_info *ioui;
294         u8 slot;
295         int i;
296
297         ioui = (struct ib_dm_iou_info *)mad->data;
298         ioui->change_id = 1;
299         ioui->max_controllers = 16;
300
301         /* set present for slot 1 and empty for the rest */
302         srpt_set_ioc(ioui->controller_list, 1, 1);
303         for (i = 1, slot = 2; i < 16; i++, slot++)
304                 srpt_set_ioc(ioui->controller_list, slot, 0);
305
306         mad->mad_hdr.status = 0;
307 }
308
309 /*
310  * Write IOControllerprofile to mad for I/O controller (sdev, slot). See also
311  * section 16.3.3.4 IOControllerProfile in the InfiniBand Architecture
312  * Specification. See also section B.7, table B.7 in the T10 SRP r16a
313  * document.
314  */
315 static void srpt_get_ioc(struct srpt_device *sdev, u32 slot,
316                          struct ib_dm_mad *mad)
317 {
318         struct ib_dm_ioc_profile *iocp;
319
320         iocp = (struct ib_dm_ioc_profile *)mad->data;
321
322         if (!slot || slot > 16) {
323                 mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD);
324                 return;
325         }
326
327         if (slot > 2) {
328                 mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_NO_IOC);
329                 return;
330         }
331
332         memset(iocp, 0, sizeof *iocp);
333         strcpy(iocp->id_string, MELLANOX_SRPT_ID_STRING);
334         iocp->guid = cpu_to_be64(srpt_service_guid);
335         iocp->vendor_id = cpu_to_be32(sdev->dev_attr.vendor_id);
336         iocp->device_id = cpu_to_be32(sdev->dev_attr.vendor_part_id);
337         iocp->device_version = cpu_to_be16(sdev->dev_attr.hw_ver);
338         iocp->subsys_vendor_id = cpu_to_be32(sdev->dev_attr.vendor_id);
339         iocp->subsys_device_id = 0x0;
340         iocp->io_class = cpu_to_be16(SRP_REV16A_IB_IO_CLASS);
341         iocp->io_subclass = cpu_to_be16(SRP_IO_SUBCLASS);
342         iocp->protocol = cpu_to_be16(SRP_PROTOCOL);
343         iocp->protocol_version = cpu_to_be16(SRP_PROTOCOL_VERSION);
344         iocp->send_queue_depth = cpu_to_be16(SRPT_SRQ_SIZE);
345         iocp->rdma_read_depth = 4;
346         iocp->send_size = cpu_to_be32(srp_max_message_size);
347         iocp->rdma_size = cpu_to_be32(min(max(srp_max_rdma_size, 256U),
348                                           1U << 24));
349         iocp->num_svc_entries = 1;
350         iocp->op_cap_mask = SRP_SEND_TO_IOC | SRP_SEND_FROM_IOC |
351                 SRP_RDMA_READ_FROM_IOC | SRP_RDMA_WRITE_FROM_IOC;
352
353         mad->mad_hdr.status = 0;
354 }
355
356 /*
357  * Device management: write ServiceEntries to mad for the given slot. See also
358  * section 16.3.3.5 ServiceEntries in the InfiniBand Architecture
359  * Specification. See also section B.7, table B.8 in the T10 SRP r16a document.
360  */
361 static void srpt_get_svc_entries(u64 ioc_guid,
362                                  u16 slot, u8 hi, u8 lo, struct ib_dm_mad *mad)
363 {
364         struct ib_dm_svc_entries *svc_entries;
365
366         WARN_ON(!ioc_guid);
367
368         if (!slot || slot > 16) {
369                 mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD);
370                 return;
371         }
372
373         if (slot > 2 || lo > hi || hi > 1) {
374                 mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_NO_IOC);
375                 return;
376         }
377
378         svc_entries = (struct ib_dm_svc_entries *)mad->data;
379         memset(svc_entries, 0, sizeof *svc_entries);
380         svc_entries->service_entries[0].id = cpu_to_be64(ioc_guid);
381         snprintf(svc_entries->service_entries[0].name,
382                  sizeof(svc_entries->service_entries[0].name),
383                  "%s%016llx",
384                  SRP_SERVICE_NAME_PREFIX,
385                  (unsigned long long)ioc_guid);
386
387         mad->mad_hdr.status = 0;
388 }
389
390 /*
391  * Actual processing of a received MAD *rq_mad received through source port *sp
392  * (MAD = InfiniBand management datagram). The response to be sent back is
393  * written to *rsp_mad.
394  */
395 static void srpt_mgmt_method_get(struct srpt_port *sp, struct ib_mad *rq_mad,
396                                  struct ib_dm_mad *rsp_mad)
397 {
398         u16 attr_id;
399         u32 slot;
400         u8 hi, lo;
401
402         attr_id = be16_to_cpu(rq_mad->mad_hdr.attr_id);
403         switch (attr_id) {
404         case DM_ATTR_CLASS_PORT_INFO:
405                 srpt_get_class_port_info(rsp_mad);
406                 break;
407         case DM_ATTR_IOU_INFO:
408                 srpt_get_iou(rsp_mad);
409                 break;
410         case DM_ATTR_IOC_PROFILE:
411                 slot = be32_to_cpu(rq_mad->mad_hdr.attr_mod);
412                 srpt_get_ioc(sp->sdev, slot, rsp_mad);
413                 break;
414         case DM_ATTR_SVC_ENTRIES:
415                 slot = be32_to_cpu(rq_mad->mad_hdr.attr_mod);
416                 hi = (u8) ((slot >> 8) & 0xff);
417                 lo = (u8) (slot & 0xff);
418                 slot = (u16) ((slot >> 16) & 0xffff);
419                 srpt_get_svc_entries(srpt_service_guid,
420                                      slot, hi, lo, rsp_mad);
421                 break;
422         default:
423                 rsp_mad->mad_hdr.status =
424                     cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
425                 break;
426         }
427 }
428
429 /*
430  * Callback function that is called by the InfiniBand core after transmission of
431  * a MAD. (MAD = management datagram; AH = address handle.)
432  */
433 static void srpt_mad_send_handler(struct ib_mad_agent *mad_agent,
434                                   struct ib_mad_send_wc *mad_wc)
435 {
436         ib_destroy_ah(mad_wc->send_buf->ah);
437         ib_free_send_mad(mad_wc->send_buf);
438 }
439
440 /*
441  * Callback function that is called by the InfiniBand core after reception of
442  * a MAD (management datagram).
443  */
444 static void srpt_mad_recv_handler(struct ib_mad_agent *mad_agent,
445                                   struct ib_mad_recv_wc *mad_wc)
446 {
447         struct srpt_port *sport = (struct srpt_port *)mad_agent->context;
448         struct ib_ah *ah;
449         struct ib_mad_send_buf *rsp;
450         struct ib_dm_mad *dm_mad;
451
452         if (!mad_wc || !mad_wc->recv_buf.mad)
453                 return;
454
455         ah = ib_create_ah_from_wc(mad_agent->qp->pd, mad_wc->wc,
456                                   mad_wc->recv_buf.grh, mad_agent->port_num);
457         if (IS_ERR(ah))
458                 goto err;
459
460         BUILD_BUG_ON(offsetof(struct ib_dm_mad, data) != IB_MGMT_DEVICE_HDR);
461
462         rsp = ib_create_send_mad(mad_agent, mad_wc->wc->src_qp,
463                                  mad_wc->wc->pkey_index, 0,
464                                  IB_MGMT_DEVICE_HDR, IB_MGMT_DEVICE_DATA,
465                                  GFP_KERNEL);
466         if (IS_ERR(rsp))
467                 goto err_rsp;
468
469         rsp->ah = ah;
470
471         dm_mad = rsp->mad;
472         memcpy(dm_mad, mad_wc->recv_buf.mad, sizeof *dm_mad);
473         dm_mad->mad_hdr.method = IB_MGMT_METHOD_GET_RESP;
474         dm_mad->mad_hdr.status = 0;
475
476         switch (mad_wc->recv_buf.mad->mad_hdr.method) {
477         case IB_MGMT_METHOD_GET:
478                 srpt_mgmt_method_get(sport, mad_wc->recv_buf.mad, dm_mad);
479                 break;
480         case IB_MGMT_METHOD_SET:
481                 dm_mad->mad_hdr.status =
482                     cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
483                 break;
484         default:
485                 dm_mad->mad_hdr.status =
486                     cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD);
487                 break;
488         }
489
490         if (!ib_post_send_mad(rsp, NULL)) {
491                 ib_free_recv_mad(mad_wc);
492                 /* will destroy_ah & free_send_mad in send completion */
493                 return;
494         }
495
496         ib_free_send_mad(rsp);
497
498 err_rsp:
499         ib_destroy_ah(ah);
500 err:
501         ib_free_recv_mad(mad_wc);
502 }
503
504 /*
505  * Enable InfiniBand management datagram processing, update the cached sm_lid,
506  * lid and gid values, and register a callback function for processing MADs
507  * on the specified port. It is safe to call this function more than once for
508  * the same port.
509  */
510 static int srpt_refresh_port(struct srpt_port *sport)
511 {
512         struct ib_mad_reg_req reg_req;
513         struct ib_port_modify port_modify;
514         struct ib_port_attr port_attr;
515         int ret;
516
517         TRACE_ENTRY();
518
519         memset(&port_modify, 0, sizeof port_modify);
520         port_modify.set_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP;
521         port_modify.clr_port_cap_mask = 0;
522
523         ret = ib_modify_port(sport->sdev->device, sport->port, 0, &port_modify);
524         if (ret)
525                 goto err_mod_port;
526
527         ret = ib_query_port(sport->sdev->device, sport->port, &port_attr);
528         if (ret)
529                 goto err_query_port;
530
531         sport->sm_lid = port_attr.sm_lid;
532         sport->lid = port_attr.lid;
533
534         ret = ib_query_gid(sport->sdev->device, sport->port, 0, &sport->gid);
535         if (ret)
536                 goto err_query_port;
537
538         if (!sport->mad_agent) {
539                 memset(&reg_req, 0, sizeof reg_req);
540                 reg_req.mgmt_class = IB_MGMT_CLASS_DEVICE_MGMT;
541                 reg_req.mgmt_class_version = IB_MGMT_BASE_VERSION;
542                 set_bit(IB_MGMT_METHOD_GET, reg_req.method_mask);
543                 set_bit(IB_MGMT_METHOD_SET, reg_req.method_mask);
544
545                 sport->mad_agent = ib_register_mad_agent(sport->sdev->device,
546                                                          sport->port,
547                                                          IB_QPT_GSI,
548                                                          &reg_req, 0,
549                                                          srpt_mad_send_handler,
550                                                          srpt_mad_recv_handler,
551                                                          sport);
552                 if (IS_ERR(sport->mad_agent)) {
553                         ret = PTR_ERR(sport->mad_agent);
554                         sport->mad_agent = NULL;
555                         goto err_query_port;
556                 }
557         }
558
559         TRACE_EXIT_RES(0);
560
561         return 0;
562
563 err_query_port:
564
565         port_modify.set_port_cap_mask = 0;
566         port_modify.clr_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP;
567         ib_modify_port(sport->sdev->device, sport->port, 0, &port_modify);
568
569 err_mod_port:
570
571         TRACE_EXIT_RES(ret);
572
573         return ret;
574 }
575
576 /*
577  * Unregister the callback function for processing MADs and disable MAD
578  * processing for all ports of the specified device. It is safe to call this
579  * function more than once for the same device.
580  */
581 static void srpt_unregister_mad_agent(struct srpt_device *sdev)
582 {
583         struct ib_port_modify port_modify = {
584                 .clr_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP,
585         };
586         struct srpt_port *sport;
587         int i;
588
589         for (i = 1; i <= sdev->device->phys_port_cnt; i++) {
590                 sport = &sdev->port[i - 1];
591                 WARN_ON(sport->port != i);
592                 if (ib_modify_port(sdev->device, i, 0, &port_modify) < 0)
593                         PRINT_ERROR("%s", "disabling MAD processing failed.");
594                 if (sport->mad_agent) {
595                         ib_unregister_mad_agent(sport->mad_agent);
596                         sport->mad_agent = NULL;
597                 }
598         }
599 }
600
601 /**
602  * Allocate and initialize an SRPT I/O context structure.
603  */
604 static struct srpt_ioctx *srpt_alloc_ioctx(struct srpt_device *sdev)
605 {
606         struct srpt_ioctx *ioctx;
607
608         ioctx = kmalloc(sizeof *ioctx, GFP_KERNEL);
609         if (!ioctx)
610                 goto out;
611
612         ioctx->buf = kzalloc(srp_max_message_size, GFP_KERNEL);
613         if (!ioctx->buf)
614                 goto out_free_ioctx;
615
616         ioctx->dma = ib_dma_map_single(sdev->device, ioctx->buf,
617                                        srp_max_message_size, DMA_BIDIRECTIONAL);
618         if (ib_dma_mapping_error(sdev->device, ioctx->dma))
619                 goto out_free_buf;
620
621         return ioctx;
622
623 out_free_buf:
624         kfree(ioctx->buf);
625 out_free_ioctx:
626         kfree(ioctx);
627 out:
628         return NULL;
629 }
630
631 /*
632  * Deallocate an SRPT I/O context structure.
633  */
634 static void srpt_free_ioctx(struct srpt_device *sdev, struct srpt_ioctx *ioctx)
635 {
636         if (!ioctx)
637                 return;
638
639         ib_dma_unmap_single(sdev->device, ioctx->dma,
640                             srp_max_message_size, DMA_BIDIRECTIONAL);
641         kfree(ioctx->buf);
642         kfree(ioctx);
643 }
644
645 /**
646  * srpt_alloc_ioctx_ring() -- allocate a ring of SRPT I/O context structures.
647  * @sdev: device to allocate the I/O context ring for.
648  * @ioctx_ring: pointer to an array of I/O contexts.
649  * @ring_size: number of elements in the I/O context ring.
650  * @flags: flags to be set in the ring index.
651  */
652 static int srpt_alloc_ioctx_ring(struct srpt_device *sdev,
653                                  struct srpt_ioctx **ioctx_ring,
654                                  int ring_size,
655                                  u32 flags)
656 {
657         int res;
658         int i;
659
660         TRACE_ENTRY();
661
662         res = -ENOMEM;
663         for (i = 0; i < ring_size; ++i) {
664                 ioctx_ring[i] = srpt_alloc_ioctx(sdev);
665
666                 if (!ioctx_ring[i])
667                         goto err;
668
669                 WARN_ON(i & flags);
670                 ioctx_ring[i]->index = i | flags;
671         }
672         res = 0;
673         goto out;
674
675 err:
676         while (--i >= 0) {
677                 srpt_free_ioctx(sdev, ioctx_ring[i]);
678                 ioctx_ring[i] = NULL;
679         }
680 out:
681         TRACE_EXIT_RES(res);
682         return res;
683 }
684
685 /* Free the ring of SRPT I/O context structures. */
686 static void srpt_free_ioctx_ring(struct srpt_device *sdev,
687                                  struct srpt_ioctx **ioctx_ring,
688                                  int ring_size)
689 {
690         int i;
691
692         for (i = 0; i < ring_size; ++i) {
693                 srpt_free_ioctx(sdev, ioctx_ring[i]);
694                 ioctx_ring[i] = NULL;
695         }
696 }
697
698 /**
699  * srpt_get_cmd_state() - Get the state of a SCSI command.
700  */
701 static enum srpt_command_state srpt_get_cmd_state(struct srpt_ioctx *ioctx)
702 {
703         BUG_ON(!ioctx);
704
705         return atomic_read(&ioctx->state);
706 }
707
708 /**
709  * srpt_set_cmd_state() - Set the state of a SCSI command.
710  * @new: New state to be set.
711  *
712  * Does not modify the state of aborted commands. Returns the previous command
713  * state.
714  */
715 static enum srpt_command_state srpt_set_cmd_state(struct srpt_ioctx *ioctx,
716                                                   enum srpt_command_state new)
717 {
718         enum srpt_command_state previous;
719
720         BUG_ON(!ioctx);
721         WARN_ON(new == SRPT_STATE_NEW);
722
723         do {
724                 previous = atomic_read(&ioctx->state);
725         } while (previous != SRPT_STATE_DONE
726                && atomic_cmpxchg(&ioctx->state, previous, new) != previous);
727
728         return previous;
729 }
730
731 /**
732  * Test and set the state of a command.
733  * @old: State to compare against.
734  * @new: New state to be set if the current state matches 'old'.
735  *
736  * Returns the previous command state.
737  */
738 static enum srpt_command_state
739 srpt_test_and_set_cmd_state(struct srpt_ioctx *ioctx,
740                             enum srpt_command_state old,
741                             enum srpt_command_state new)
742 {
743         WARN_ON(!ioctx);
744         WARN_ON(old == SRPT_STATE_DONE);
745         WARN_ON(new == SRPT_STATE_NEW);
746
747         return atomic_cmpxchg(&ioctx->state, old, new);
748 }
749
750 /**
751  * Post a receive request on the work queue of InfiniBand device 'sdev'.
752  */
753 static int srpt_post_recv(struct srpt_device *sdev, struct srpt_ioctx *ioctx)
754 {
755         struct ib_sge list;
756         struct ib_recv_wr wr, *bad_wr;
757
758         wr.wr_id = ioctx->index | SRPT_OP_RECV;
759
760         list.addr = ioctx->dma;
761         list.length = srp_max_message_size;
762         list.lkey = sdev->mr->lkey;
763
764         wr.next = NULL;
765         wr.sg_list = &list;
766         wr.num_sge = 1;
767
768         return ib_post_srq_recv(sdev->srq, &wr, &bad_wr);
769 }
770
771 /**
772  * Post an IB send request.
773  * @ch: RDMA channel to post the send request on.
774  * @ioctx: I/O context of the send request.
775  * @len: length of the request to be sent in bytes.
776  *
777  * Returns zero upon success and a non-zero value upon failure.
778  */
779 static int srpt_post_send(struct srpt_rdma_ch *ch, struct srpt_ioctx *ioctx,
780                           int len)
781 {
782         struct ib_sge list;
783         struct ib_send_wr wr, *bad_wr;
784         struct srpt_device *sdev = ch->sport->sdev;
785         int ret;
786
787         ret = -ENOMEM;
788         if (atomic_dec_return(&ch->qp_wr_avail) < 0) {
789                 PRINT_ERROR("%s[%d]: SRQ full", __func__, __LINE__);
790                 goto out;
791         }
792
793         ib_dma_sync_single_for_device(sdev->device, ioctx->dma,
794                                       len, DMA_TO_DEVICE);
795
796         list.addr = ioctx->dma;
797         list.length = len;
798         list.lkey = sdev->mr->lkey;
799
800         wr.next = NULL;
801         wr.wr_id = ioctx->index;
802         wr.sg_list = &list;
803         wr.num_sge = 1;
804         wr.opcode = IB_WR_SEND;
805         wr.send_flags = IB_SEND_SIGNALED;
806
807         ret = ib_post_send(ch->qp, &wr, &bad_wr);
808
809 out:
810         if (ret < 0)
811                 atomic_inc(&ch->qp_wr_avail);
812         return ret;
813 }
814
815 /**
816  * srpt_get_desc_tbl() - Parse the data descriptors of an SRP_CMD request.
817  * @ioctx: Pointer to the I/O context associated with the request.
818  * @srp_cmd: Pointer to the SRP_CMD request data.
819  * @dir: Pointer to the variable to which the transfer direction will be
820  *   written.
821  * @data_len: Pointer to the variable to which the total data length of all
822  *   descriptors in the SRP_CMD request will be written.
823  *
824  * This function initializes ioctx->nrbuf and ioctx->r_bufs.
825  *
826  * Returns -EINVAL when the SRP_CMD request contains inconsistent descriptors;
827  * -ENOMEM when memory allocation fails and zero upon success.
828  */
829 static int srpt_get_desc_tbl(struct srpt_ioctx *ioctx, struct srp_cmd *srp_cmd,
830                              scst_data_direction *dir, u64 *data_len)
831 {
832         struct srp_indirect_buf *idb;
833         struct srp_direct_buf *db;
834         unsigned add_cdb_offset;
835         int ret;
836
837         /*
838          * The pointer computations below will only be compiled correctly
839          * if srp_cmd::add_data is declared as s8*, u8*, s8[] or u8[], so check
840          * whether srp_cmd::add_data has been declared as a byte pointer.
841          */
842 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
843         BUILD_BUG_ON(!__same_type(srp_cmd->add_data[0], (s8)0)
844                      && !__same_type(srp_cmd->add_data[0], (u8)0));
845 #else
846         /* Note: the __same_type() macro has been introduced in kernel 2.6.31.*/
847 #endif
848
849         BUG_ON(!dir);
850         BUG_ON(!data_len);
851
852         ret = 0;
853         *data_len = 0;
854
855         /*
856          * The lower four bits of the buffer format field contain the DATA-IN
857          * buffer descriptor format, and the highest four bits contain the
858          * DATA-OUT buffer descriptor format.
859          */
860         *dir = SCST_DATA_NONE;
861         if (srp_cmd->buf_fmt & 0xf)
862                 /* DATA-IN: transfer data from target to initiator. */
863                 *dir = SCST_DATA_READ;
864         else if (srp_cmd->buf_fmt >> 4)
865                 /* DATA-OUT: transfer data from initiator to target. */
866                 *dir = SCST_DATA_WRITE;
867
868         /*
869          * According to the SRP spec, the lower two bits of the 'ADDITIONAL
870          * CDB LENGTH' field are reserved and the size in bytes of this field
871          * is four times the value specified in bits 3..7. Hence the "& ~3".
872          */
873         add_cdb_offset = srp_cmd->add_cdb_len & ~3;
874         if (((srp_cmd->buf_fmt & 0xf) == SRP_DATA_DESC_DIRECT) ||
875             ((srp_cmd->buf_fmt >> 4) == SRP_DATA_DESC_DIRECT)) {
876                 ioctx->n_rbuf = 1;
877                 ioctx->rbufs = &ioctx->single_rbuf;
878
879                 db = (struct srp_direct_buf *)(srp_cmd->add_data
880                                                + add_cdb_offset);
881                 memcpy(ioctx->rbufs, db, sizeof *db);
882                 *data_len = be32_to_cpu(db->len);
883         } else if (((srp_cmd->buf_fmt & 0xf) == SRP_DATA_DESC_INDIRECT) ||
884                    ((srp_cmd->buf_fmt >> 4) == SRP_DATA_DESC_INDIRECT)) {
885                 idb = (struct srp_indirect_buf *)(srp_cmd->add_data
886                                                   + add_cdb_offset);
887
888                 ioctx->n_rbuf = be32_to_cpu(idb->table_desc.len) / sizeof *db;
889
890                 if (ioctx->n_rbuf >
891                     (srp_cmd->data_out_desc_cnt + srp_cmd->data_in_desc_cnt)) {
892                         PRINT_ERROR("received corrupt SRP_CMD request"
893                                     " (%u out + %u in != %u / %zu)",
894                                     srp_cmd->data_out_desc_cnt,
895                                     srp_cmd->data_in_desc_cnt,
896                                     be32_to_cpu(idb->table_desc.len),
897                                     sizeof(*db));
898                         ioctx->n_rbuf = 0;
899                         ret = -EINVAL;
900                         goto out;
901                 }
902
903                 if (ioctx->n_rbuf == 1)
904                         ioctx->rbufs = &ioctx->single_rbuf;
905                 else {
906                         ioctx->rbufs =
907                                 kmalloc(ioctx->n_rbuf * sizeof *db, GFP_ATOMIC);
908                         if (!ioctx->rbufs) {
909                                 ioctx->n_rbuf = 0;
910                                 ret = -ENOMEM;
911                                 goto out;
912                         }
913                 }
914
915                 db = idb->desc_list;
916                 memcpy(ioctx->rbufs, db, ioctx->n_rbuf * sizeof *db);
917                 *data_len = be32_to_cpu(idb->len);
918         }
919 out:
920         return ret;
921 }
922
923 /*
924  * Modify the attributes of queue pair 'qp': allow local write, remote read,
925  * and remote write. Also transition 'qp' to state IB_QPS_INIT.
926  */
927 static int srpt_init_ch_qp(struct srpt_rdma_ch *ch, struct ib_qp *qp)
928 {
929         struct ib_qp_attr *attr;
930         int ret;
931
932         attr = kzalloc(sizeof *attr, GFP_KERNEL);
933         if (!attr)
934                 return -ENOMEM;
935
936         attr->qp_state = IB_QPS_INIT;
937         attr->qp_access_flags = IB_ACCESS_LOCAL_WRITE | IB_ACCESS_REMOTE_READ |
938             IB_ACCESS_REMOTE_WRITE;
939         attr->port_num = ch->sport->port;
940         attr->pkey_index = 0;
941
942         ret = ib_modify_qp(qp, attr,
943                            IB_QP_STATE | IB_QP_ACCESS_FLAGS | IB_QP_PORT |
944                            IB_QP_PKEY_INDEX);
945
946         kfree(attr);
947         return ret;
948 }
949
950 /**
951  * Change the state of a channel to 'ready to receive' (RTR).
952  * @ch: channel of the queue pair.
953  * @qp: queue pair to change the state of.
954  *
955  * Returns zero upon success and a negative value upon failure.
956  *
957  * Note: currently a struct ib_qp_attr takes 136 bytes on a 64-bit system.
958  * If this structure ever becomes larger, it might be necessary to allocate
959  * it dynamically instead of on the stack.
960  */
961 static int srpt_ch_qp_rtr(struct srpt_rdma_ch *ch, struct ib_qp *qp)
962 {
963         struct ib_qp_attr qp_attr;
964         int attr_mask;
965         int ret;
966
967         qp_attr.qp_state = IB_QPS_RTR;
968         ret = ib_cm_init_qp_attr(ch->cm_id, &qp_attr, &attr_mask);
969         if (ret)
970                 goto out;
971
972         qp_attr.max_dest_rd_atomic = 4;
973
974         ret = ib_modify_qp(qp, &qp_attr, attr_mask);
975
976 out:
977         return ret;
978 }
979
980 /**
981  * Change the state of a channel to 'ready to send' (RTS).
982  * @ch: channel of the queue pair.
983  * @qp: queue pair to change the state of.
984  *
985  * Returns zero upon success and a negative value upon failure.
986  *
987  * Note: currently a struct ib_qp_attr takes 136 bytes on a 64-bit system.
988  * If this structure ever becomes larger, it might be necessary to allocate
989  * it dynamically instead of on the stack.
990  */
991 static int srpt_ch_qp_rts(struct srpt_rdma_ch *ch, struct ib_qp *qp)
992 {
993         struct ib_qp_attr qp_attr;
994         int attr_mask;
995         int ret;
996
997         qp_attr.qp_state = IB_QPS_RTS;
998         ret = ib_cm_init_qp_attr(ch->cm_id, &qp_attr, &attr_mask);
999         if (ret)
1000                 goto out;
1001
1002         qp_attr.max_rd_atomic = 4;
1003
1004         ret = ib_modify_qp(qp, &qp_attr, attr_mask);
1005
1006 out:
1007         return ret;
1008 }
1009
1010 /**
1011  * srpt_req_lim_delta() - Compute by how much req_lim changed since the
1012  * last time this function has been called. This value is necessary for
1013  * filling in the REQUEST LIMIT DELTA field of an SRP_RSP response.
1014  *
1015  * Side Effect: Modifies ch->last_response_req_lim.
1016  */
1017 static int srpt_req_lim_delta(struct srpt_rdma_ch *ch)
1018 {
1019         int req_lim;
1020         int last_rsp_req_lim;
1021
1022         req_lim = atomic_read(&ch->req_lim);
1023         last_rsp_req_lim = atomic_xchg(&ch->last_response_req_lim, req_lim);
1024         return req_lim - last_rsp_req_lim;
1025 }
1026
1027 static void srpt_reset_ioctx(struct srpt_rdma_ch *ch, struct srpt_ioctx *ioctx)
1028 {
1029         BUG_ON(!ch);
1030         BUG_ON(!ioctx);
1031
1032         /*
1033          * If the WARN_ON() below gets triggered this means that
1034          * srpt_unmap_sg_to_ib_sge() has not been called before
1035          * scst_tgt_cmd_done().
1036          */
1037         WARN_ON(ioctx->mapped_sg_count);
1038
1039         if (ioctx->n_rbuf > 1) {
1040                 kfree(ioctx->rbufs);
1041                 ioctx->rbufs = NULL;
1042                 ioctx->n_rbuf = 0;
1043         }
1044
1045         if (srpt_post_recv(ch->sport->sdev, ioctx))
1046                 PRINT_ERROR("%s", "SRQ post_recv failed - this is serious.");
1047                 /* we should queue it back to free_ioctx queue */
1048         else {
1049                 int req_lim;
1050
1051                 req_lim = atomic_inc_return(&ch->req_lim);
1052                 if (req_lim < 0 || req_lim > SRPT_RQ_SIZE)
1053                         PRINT_ERROR("internal error: req_lim = %d out of range"
1054                                     "%d .. %d", req_lim, 0, SRPT_RQ_SIZE);
1055         }
1056 }
1057
1058 /**
1059  * srpt_abort_scst_cmd() - Abort a SCSI command.
1060  */
1061 static void srpt_abort_scst_cmd(struct srpt_ioctx *ioctx,
1062                                 enum scst_exec_context context)
1063 {
1064         struct scst_cmd *scmnd;
1065         enum srpt_command_state state;
1066
1067         TRACE_ENTRY();
1068
1069         BUG_ON(!ioctx);
1070
1071         state = srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
1072         if (state == SRPT_STATE_DONE)
1073                 goto out;
1074
1075         scmnd = ioctx->scmnd;
1076         WARN_ON(!scmnd);
1077         if (!scmnd)
1078                 goto out;
1079
1080         WARN_ON(ioctx != scst_cmd_get_tgt_priv(scmnd));
1081
1082         TRACE_DBG("Aborting cmd with state %d and tag %lld",
1083                   state, scst_cmd_get_tag(scmnd));
1084
1085         srpt_unmap_sg_to_ib_sge(ioctx->ch, ioctx);
1086
1087         switch (state) {
1088         case SRPT_STATE_NEW:
1089                 scst_set_delivery_status(scmnd, SCST_CMD_DELIVERY_ABORTED);
1090                 break;
1091         case SRPT_STATE_NEED_DATA:
1092                 scst_rx_data(scmnd, SCST_RX_STATUS_ERROR, context);
1093                 break;
1094         case SRPT_STATE_DATA_IN:
1095         case SRPT_STATE_CMD_RSP_SENT:
1096                 scst_set_delivery_status(scmnd, SCST_CMD_DELIVERY_ABORTED);
1097                 break;
1098         case SRPT_STATE_MGMT_RSP_SENT:
1099                 WARN_ON(!"ERROR: srpt_abort_scst_cmd() has been called for"
1100                         " a management command.");
1101                 break;
1102         default:
1103                 WARN_ON(!"ERROR: unexpected command state");
1104                 break;
1105         }
1106         scst_tgt_cmd_done(scmnd, context);
1107
1108 out:
1109         ;
1110
1111         TRACE_EXIT();
1112 }
1113
1114 static void srpt_handle_err_comp(struct srpt_rdma_ch *ch, struct ib_wc *wc,
1115                                  enum scst_exec_context context)
1116 {
1117         struct srpt_ioctx *ioctx;
1118         struct srpt_device *sdev = ch->sport->sdev;
1119
1120         TRACE_DBG("%s:%d wr_id = %#llx.", __func__, __LINE__, wc->wr_id);
1121
1122         if (wc->wr_id & SRPT_OP_RECV) {
1123                 ioctx = sdev->ioctx_ring[wc->wr_id & ~SRPT_OP_RECV];
1124                 PRINT_ERROR("%s", "This is serious - SRQ is in bad state.");
1125         } else {
1126                 ioctx = sdev->ioctx_ring[wc->wr_id];
1127
1128                 if (ioctx->scmnd)
1129                         srpt_abort_scst_cmd(ioctx, context);
1130                 else
1131                         srpt_reset_ioctx(ch, ioctx);
1132         }
1133 }
1134
1135 /** Process an IB send completion notification. */
1136 static void srpt_handle_send_comp(struct srpt_rdma_ch *ch,
1137                                   struct srpt_ioctx *ioctx,
1138                                   enum scst_exec_context context)
1139 {
1140         enum srpt_command_state state;
1141         struct scst_cmd *scmnd;
1142
1143         state = srpt_get_cmd_state(ioctx);
1144         scmnd = ioctx->scmnd;
1145
1146         WARN_ON(state != SRPT_STATE_CMD_RSP_SENT
1147                 && state != SRPT_STATE_MGMT_RSP_SENT);
1148         WARN_ON(state == SRPT_STATE_MGMT_RSP_SENT && scmnd);
1149
1150         if (scmnd) {
1151                 srpt_unmap_sg_to_ib_sge(ch, ioctx);
1152                 srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
1153                 scst_tgt_cmd_done(scmnd, context);
1154         } else
1155                 srpt_reset_ioctx(ch, ioctx);
1156 }
1157
1158 /** Process an IB RDMA completion notification. */
1159 static void srpt_handle_rdma_comp(struct srpt_rdma_ch *ch,
1160                                   struct srpt_ioctx *ioctx,
1161                                   enum scst_exec_context context)
1162 {
1163         enum srpt_command_state state;
1164         struct scst_cmd *scmnd;
1165
1166         scmnd = ioctx->scmnd;
1167         WARN_ON(!scmnd);
1168         if (!scmnd)
1169                 return;
1170
1171         state = srpt_test_and_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA,
1172                                             SRPT_STATE_DATA_IN);
1173
1174         WARN_ON(state != SRPT_STATE_NEED_DATA);
1175
1176         if (unlikely(scst_cmd_aborted(scmnd)))
1177                 srpt_abort_scst_cmd(ioctx, context);
1178         else {
1179                 srpt_unmap_sg_to_ib_sge(ch, ioctx);
1180                 scst_rx_data(ioctx->scmnd, SCST_RX_STATUS_SUCCESS, context);
1181         }
1182 }
1183
1184 /**
1185  * srpt_build_cmd_rsp() - Build an SRP_RSP response.
1186  * @ch: RDMA channel through which the request has been received.
1187  * @ioctx: I/O context associated with the SRP_CMD request. The response will
1188  *   be built in the buffer ioctx->buf points at and hence this function will
1189  *   overwrite the request data.
1190  * @tag: tag of the request for which this response is being generated.
1191  * @status: value for the STATUS field of the SRP_RSP information unit.
1192  * @sense_data: pointer to sense data to be included in the response.
1193  * @sense_data_len: length in bytes of the sense data.
1194  *
1195  * Returns the size in bytes of the SRP_RSP response.
1196  *
1197  * An SRP_RSP response contains a SCSI status or service response. See also
1198  * section 6.9 in the T10 SRP r16a document for the format of an SRP_RSP
1199  * response. See also SPC-2 for more information about sense data.
1200  */
1201 static int srpt_build_cmd_rsp(struct srpt_rdma_ch *ch,
1202                               struct srpt_ioctx *ioctx, s32 req_lim_delta,
1203                               u64 tag, int status,
1204                               const u8 *sense_data, int sense_data_len)
1205 {
1206         struct srp_rsp *srp_rsp;
1207         int max_sense_len;
1208
1209         /*
1210          * The lowest bit of all SAM-3 status codes is zero (see also
1211          * paragraph 5.3 in SAM-3).
1212          */
1213         WARN_ON(status & 1);
1214
1215         srp_rsp = ioctx->buf;
1216         BUG_ON(!srp_rsp);
1217         memset(srp_rsp, 0, sizeof *srp_rsp);
1218
1219         srp_rsp->opcode = SRP_RSP;
1220         srp_rsp->req_lim_delta = cpu_to_be32(req_lim_delta);
1221         srp_rsp->tag = tag;
1222
1223         if (SCST_SENSE_VALID(sense_data)) {
1224                 BUILD_BUG_ON(MIN_MAX_MESSAGE_SIZE <= sizeof(*srp_rsp));
1225                 max_sense_len = ch->max_ti_iu_len - sizeof(*srp_rsp);
1226                 if (sense_data_len > max_sense_len) {
1227                         PRINT_WARNING("truncated sense data from %d to %d"
1228                                 " bytes", sense_data_len,
1229                                 max_sense_len);
1230                         sense_data_len = max_sense_len;
1231                 }
1232
1233                 srp_rsp->flags |= SRP_RSP_FLAG_SNSVALID;
1234                 srp_rsp->status = status;
1235                 srp_rsp->sense_data_len = cpu_to_be32(sense_data_len);
1236                 memcpy(srp_rsp + 1, sense_data, sense_data_len);
1237         } else
1238                 sense_data_len = 0;
1239
1240         return sizeof(*srp_rsp) + sense_data_len;
1241 }
1242
1243 /**
1244  * Build a task management response, which is a specific SRP_RSP response.
1245  * @ch: RDMA channel through which the request has been received.
1246  * @ioctx: I/O context in which the SRP_RSP response will be built.
1247  * @rsp_code: RSP_CODE that will be stored in the response.
1248  * @tag: tag of the request for which this response is being generated.
1249  *
1250  * Returns the size in bytes of the SRP_RSP response.
1251  *
1252  * An SRP_RSP response contains a SCSI status or service response. See also
1253  * section 6.9 in the T10 SRP r16a document for the format of an SRP_RSP
1254  * response.
1255  */
1256 static int srpt_build_tskmgmt_rsp(struct srpt_rdma_ch *ch,
1257                                   struct srpt_ioctx *ioctx, s32 req_lim_delta,
1258                                   u8 rsp_code, u64 tag)
1259 {
1260         struct srp_rsp *srp_rsp;
1261         int resp_data_len;
1262         int resp_len;
1263
1264         resp_data_len = (rsp_code == SRP_TSK_MGMT_SUCCESS) ? 0 : 4;
1265         resp_len = sizeof(*srp_rsp) + resp_data_len;
1266
1267         srp_rsp = ioctx->buf;
1268         memset(srp_rsp, 0, sizeof *srp_rsp);
1269
1270         srp_rsp->opcode = SRP_RSP;
1271         srp_rsp->req_lim_delta = cpu_to_be32(req_lim_delta);
1272         srp_rsp->tag = tag;
1273
1274         if (rsp_code != SRP_TSK_MGMT_SUCCESS) {
1275                 srp_rsp->flags |= SRP_RSP_FLAG_RSPVALID;
1276                 srp_rsp->resp_data_len = cpu_to_be32(resp_data_len);
1277                 srp_rsp->data[3] = rsp_code;
1278         }
1279
1280         return resp_len;
1281 }
1282
1283 /*
1284  * Process SRP_CMD.
1285  */
1286 static int srpt_handle_cmd(struct srpt_rdma_ch *ch, struct srpt_ioctx *ioctx,
1287                            enum scst_exec_context context)
1288 {
1289         struct scst_cmd *scmnd;
1290         struct srp_cmd *srp_cmd;
1291         scst_data_direction dir;
1292         u64 data_len;
1293         int ret;
1294
1295         srp_cmd = ioctx->buf;
1296
1297         scmnd = scst_rx_cmd(ch->scst_sess, (u8 *) &srp_cmd->lun,
1298                             sizeof srp_cmd->lun, srp_cmd->cdb, 16, context);
1299         if (!scmnd)
1300                 goto err;
1301
1302         ioctx->scmnd = scmnd;
1303
1304         ret = srpt_get_desc_tbl(ioctx, srp_cmd, &dir, &data_len);
1305         if (ret) {
1306                 scst_set_cmd_error(scmnd,
1307                         SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb));
1308                 goto err;
1309         }
1310
1311         switch (srp_cmd->task_attr) {
1312         case SRP_CMD_HEAD_OF_Q:
1313                 scmnd->queue_type = SCST_CMD_QUEUE_HEAD_OF_QUEUE;
1314                 break;
1315         case SRP_CMD_ORDERED_Q:
1316                 scmnd->queue_type = SCST_CMD_QUEUE_ORDERED;
1317                 break;
1318         case SRP_CMD_SIMPLE_Q:
1319                 scmnd->queue_type = SCST_CMD_QUEUE_SIMPLE;
1320                 break;
1321         case SRP_CMD_ACA:
1322                 scmnd->queue_type = SCST_CMD_QUEUE_ACA;
1323                 break;
1324         default:
1325                 scmnd->queue_type = SCST_CMD_QUEUE_ORDERED;
1326                 break;
1327         }
1328
1329         scst_cmd_set_tag(scmnd, srp_cmd->tag);
1330         scst_cmd_set_tgt_priv(scmnd, ioctx);
1331         scst_cmd_set_expected(scmnd, dir, data_len);
1332         scst_cmd_init_done(scmnd, context);
1333
1334         return 0;
1335
1336 err:
1337         return -1;
1338 }
1339
1340 /*
1341  * srpt_handle_tsk_mgmt() - Process an SRP_TSK_MGMT information unit.
1342  *
1343  * Returns SRP_TSK_MGMT_SUCCESS upon success.
1344  *
1345  * Each task management function is performed by calling one of the
1346  * scst_rx_mgmt_fn*() functions. These functions will either report failure
1347  * or process the task management function asynchronously. The function
1348  * srpt_tsk_mgmt_done() will be called by the SCST core upon completion of the
1349  * task management function. When srpt_handle_tsk_mgmt() reports failure
1350  * (i.e. returns -1) a response will have been built in ioctx->buf. This
1351  * information unit has to be sent back by the caller.
1352  *
1353  * For more information about SRP_TSK_MGMT information units, see also section
1354  * 6.7 in the T10 SRP r16a document.
1355  */
1356 static u8 srpt_handle_tsk_mgmt(struct srpt_rdma_ch *ch,
1357                                struct srpt_ioctx *ioctx)
1358 {
1359         struct srp_tsk_mgmt *srp_tsk;
1360         struct srpt_mgmt_ioctx *mgmt_ioctx;
1361         int ret;
1362         u8 srp_tsk_mgmt_status;
1363
1364         srp_tsk = ioctx->buf;
1365
1366         TRACE_DBG("recv_tsk_mgmt= %d for task_tag= %lld"
1367                   " using tag= %lld cm_id= %p sess= %p",
1368                   srp_tsk->tsk_mgmt_func,
1369                   (unsigned long long) srp_tsk->task_tag,
1370                   (unsigned long long) srp_tsk->tag,
1371                   ch->cm_id, ch->scst_sess);
1372
1373         srp_tsk_mgmt_status = SRP_TSK_MGMT_FAILED;
1374         mgmt_ioctx = kmalloc(sizeof *mgmt_ioctx, GFP_ATOMIC);
1375         if (!mgmt_ioctx)
1376                 goto err;
1377
1378         mgmt_ioctx->ioctx = ioctx;
1379         mgmt_ioctx->ch = ch;
1380         mgmt_ioctx->tag = srp_tsk->tag;
1381
1382         switch (srp_tsk->tsk_mgmt_func) {
1383         case SRP_TSK_ABORT_TASK:
1384                 TRACE_DBG("%s", "Processing SRP_TSK_ABORT_TASK");
1385                 ret = scst_rx_mgmt_fn_tag(ch->scst_sess,
1386                                           SCST_ABORT_TASK,
1387                                           srp_tsk->task_tag,
1388                                           SCST_ATOMIC, mgmt_ioctx);
1389                 break;
1390         case SRP_TSK_ABORT_TASK_SET:
1391                 TRACE_DBG("%s", "Processing SRP_TSK_ABORT_TASK_SET");
1392                 ret = scst_rx_mgmt_fn_lun(ch->scst_sess,
1393                                           SCST_ABORT_TASK_SET,
1394                                           (u8 *) &srp_tsk->lun,
1395                                           sizeof srp_tsk->lun,
1396                                           SCST_ATOMIC, mgmt_ioctx);
1397                 break;
1398         case SRP_TSK_CLEAR_TASK_SET:
1399                 TRACE_DBG("%s", "Processing SRP_TSK_CLEAR_TASK_SET");
1400                 ret = scst_rx_mgmt_fn_lun(ch->scst_sess,
1401                                           SCST_CLEAR_TASK_SET,
1402                                           (u8 *) &srp_tsk->lun,
1403                                           sizeof srp_tsk->lun,
1404                                           SCST_ATOMIC, mgmt_ioctx);
1405                 break;
1406         case SRP_TSK_LUN_RESET:
1407                 TRACE_DBG("%s", "Processing SRP_TSK_LUN_RESET");
1408                 ret = scst_rx_mgmt_fn_lun(ch->scst_sess,
1409                                           SCST_LUN_RESET,
1410                                           (u8 *) &srp_tsk->lun,
1411                                           sizeof srp_tsk->lun,
1412                                           SCST_ATOMIC, mgmt_ioctx);
1413                 break;
1414         case SRP_TSK_CLEAR_ACA:
1415                 TRACE_DBG("%s", "Processing SRP_TSK_CLEAR_ACA");
1416                 ret = scst_rx_mgmt_fn_lun(ch->scst_sess,
1417                                           SCST_CLEAR_ACA,
1418                                           (u8 *) &srp_tsk->lun,
1419                                           sizeof srp_tsk->lun,
1420                                           SCST_ATOMIC, mgmt_ioctx);
1421                 break;
1422         default:
1423                 TRACE_DBG("%s", "Unsupported task management function.");
1424                 srp_tsk_mgmt_status = SRP_TSK_MGMT_FUNC_NOT_SUPP;
1425                 goto err;
1426         }
1427
1428         if (ret) {
1429                 TRACE_DBG("Processing task management function failed"
1430                           " (ret = %d).", ret);
1431                 goto err;
1432         }
1433         return SRP_TSK_MGMT_SUCCESS;
1434
1435 err:
1436         kfree(mgmt_ioctx);
1437         return srp_tsk_mgmt_status;
1438 }
1439
1440 /**
1441  * Process a newly received information unit.
1442  * @ch: RDMA channel through which the information unit has been received.
1443  * @ioctx: SRPT I/O context associated with the information unit.
1444  */
1445 static void srpt_handle_new_iu(struct srpt_rdma_ch *ch,
1446                                struct srpt_ioctx *ioctx)
1447 {
1448         struct srp_cmd *srp_cmd;
1449         struct scst_cmd *scmnd;
1450         enum rdma_ch_state ch_state;
1451         u8 srp_response_status;
1452         u8 srp_tsk_mgmt_status;
1453         int len;
1454         int send_rsp_res;
1455         enum scst_exec_context context;
1456
1457         ch_state = atomic_read(&ch->state);
1458         if (ch_state == RDMA_CHANNEL_CONNECTING) {
1459                 list_add_tail(&ioctx->wait_list, &ch->cmd_wait_list);
1460                 return;
1461         }
1462
1463         ioctx->n_rbuf = 0;
1464         ioctx->rbufs = NULL;
1465         ioctx->n_rdma = 0;
1466         ioctx->n_rdma_ius = 0;
1467         ioctx->rdma_ius = NULL;
1468         ioctx->mapped_sg_count = 0;
1469         ioctx->scmnd = NULL;
1470         ioctx->ch = ch;
1471         atomic_set(&ioctx->state, SRPT_STATE_NEW);
1472
1473         if (ch_state == RDMA_CHANNEL_DISCONNECTING) {
1474                 srpt_reset_ioctx(ch, ioctx);
1475                 return;
1476         }
1477
1478         WARN_ON(ch_state != RDMA_CHANNEL_LIVE);
1479
1480         context = thread ? SCST_CONTEXT_THREAD : SCST_CONTEXT_TASKLET;
1481
1482         scmnd = NULL;
1483
1484         srp_response_status = SAM_STAT_BUSY;
1485         /* To keep the compiler happy. */
1486         srp_tsk_mgmt_status = -1;
1487
1488         ib_dma_sync_single_for_cpu(ch->sport->sdev->device,
1489                                    ioctx->dma, srp_max_message_size,
1490                                    DMA_FROM_DEVICE);
1491
1492         srp_cmd = ioctx->buf;
1493
1494         switch (srp_cmd->opcode) {
1495         case SRP_CMD:
1496                 if (srpt_handle_cmd(ch, ioctx, context) < 0) {
1497                         scmnd = ioctx->scmnd;
1498                         if (scmnd)
1499                                 srp_response_status =
1500                                         scst_cmd_get_status(scmnd);
1501                         goto err;
1502                 }
1503                 break;
1504
1505         case SRP_TSK_MGMT:
1506                 srp_tsk_mgmt_status = srpt_handle_tsk_mgmt(ch, ioctx);
1507                 if (srp_tsk_mgmt_status != SRP_TSK_MGMT_SUCCESS)
1508                         goto err;
1509                 break;
1510
1511         case SRP_CRED_RSP:
1512                 TRACE_DBG("%s", "received SRP_CRED_RSP");
1513                 srpt_reset_ioctx(ch, ioctx);
1514                 break;
1515
1516         case SRP_AER_RSP:
1517                 TRACE_DBG("%s", "received SRP_AER_RSP");
1518                 srpt_reset_ioctx(ch, ioctx);
1519                 break;
1520
1521         case SRP_I_LOGOUT:
1522         default:
1523                 goto err;
1524         }
1525
1526         return;
1527
1528 err:
1529         send_rsp_res = -ENOTCONN;
1530
1531         if (atomic_read(&ch->state) != RDMA_CHANNEL_LIVE) {
1532                 /* Give up if another thread modified the channel state. */
1533                 PRINT_ERROR("%s", "channel is no longer in connected state.");
1534         } else {
1535                 s32 req_lim_delta;
1536
1537                 req_lim_delta = srpt_req_lim_delta(ch) + 1;
1538                 if (srp_cmd->opcode == SRP_TSK_MGMT)
1539                         len = srpt_build_tskmgmt_rsp(ch, ioctx, req_lim_delta,
1540                                      srp_tsk_mgmt_status,
1541                                      ((struct srp_tsk_mgmt *)srp_cmd)->tag);
1542                 else if (scmnd)
1543                         len = srpt_build_cmd_rsp(ch, ioctx, req_lim_delta,
1544                                 srp_cmd->tag, srp_response_status,
1545                                 scst_cmd_get_sense_buffer(scmnd),
1546                                 scst_cmd_get_sense_buffer_len(scmnd));
1547                 else
1548                         len = srpt_build_cmd_rsp(ch, ioctx, srp_cmd->tag,
1549                                                  req_lim_delta,
1550                                                  srp_response_status,
1551                                                  NULL, 0);
1552                 srpt_set_cmd_state(ioctx,
1553                                    srp_cmd->opcode == SRP_TSK_MGMT
1554                                    ? SRPT_STATE_MGMT_RSP_SENT
1555                                    : SRPT_STATE_CMD_RSP_SENT);
1556                 send_rsp_res = srpt_post_send(ch, ioctx, len);
1557                 if (send_rsp_res) {
1558                         PRINT_ERROR("%s", "Sending SRP_RSP response failed.");
1559                         atomic_sub(req_lim_delta, &ch->last_response_req_lim);
1560                 }
1561         }
1562         if (send_rsp_res) {
1563                 if (scmnd)
1564                         srpt_abort_scst_cmd(ioctx, context);
1565                 else
1566                         srpt_reset_ioctx(ch, ioctx);
1567         }
1568 }
1569
1570 /**
1571  * InfiniBand completion queue callback function.
1572  * @cq: completion queue.
1573  * @ctx: completion queue context, which was passed as the fourth argument of
1574  *       the function ib_create_cq().
1575  */
1576 static void srpt_completion(struct ib_cq *cq, void *ctx)
1577 {
1578         struct srpt_rdma_ch *ch = ctx;
1579         struct srpt_device *sdev = ch->sport->sdev;
1580         struct ib_wc wc;
1581         struct srpt_ioctx *ioctx;
1582         enum scst_exec_context context;
1583
1584         context = thread ? SCST_CONTEXT_THREAD : SCST_CONTEXT_TASKLET;
1585
1586         ib_req_notify_cq(ch->cq, IB_CQ_NEXT_COMP);
1587         while (ib_poll_cq(ch->cq, 1, &wc) > 0) {
1588                 if (wc.status) {
1589                         PRINT_INFO("%s failed with status %d",
1590                                    wc.wr_id & SRPT_OP_RECV
1591                                    ? "receiving"
1592                                    : "sending response",
1593                                    wc.status);
1594                         srpt_handle_err_comp(ch, &wc, context);
1595                         continue;
1596                 }
1597
1598                 if (wc.wr_id & SRPT_OP_RECV) {
1599                         int req_lim;
1600
1601                         req_lim = atomic_dec_return(&ch->req_lim);
1602                         if (req_lim < 0)
1603                                 PRINT_ERROR("internal error: req_lim = %d < 0",
1604                                             req_lim);
1605                         ioctx = sdev->ioctx_ring[wc.wr_id & ~SRPT_OP_RECV];
1606                         srpt_handle_new_iu(ch, ioctx);
1607                 } else {
1608                         ioctx = sdev->ioctx_ring[wc.wr_id];
1609                         if (wc.opcode == IB_WC_SEND)
1610                                 atomic_inc(&ch->qp_wr_avail);
1611                         else {
1612                                 WARN_ON(wc.opcode != IB_WC_RDMA_READ);
1613                                 WARN_ON(ioctx->n_rdma <= 0);
1614                                 atomic_add(ioctx->n_rdma,
1615                                            &ch->qp_wr_avail);
1616                         }
1617                         switch (wc.opcode) {
1618                         case IB_WC_SEND:
1619                                 srpt_handle_send_comp(ch, ioctx, context);
1620                                 break;
1621                         case IB_WC_RDMA_WRITE:
1622                         case IB_WC_RDMA_READ:
1623                                 srpt_handle_rdma_comp(ch, ioctx, context);
1624                                 break;
1625                         default:
1626                                 PRINT_ERROR("received unrecognized"
1627                                             " IB WC opcode %d",
1628                                             wc.opcode);
1629                                 break;
1630                         }
1631                 }
1632
1633 #if defined(CONFIG_SCST_DEBUG)
1634                 if (interrupt_processing_delay_in_us <= MAX_UDELAY_MS * 1000)
1635                         udelay(interrupt_processing_delay_in_us);
1636 #endif
1637         }
1638 }
1639
1640 /*
1641  * Create a completion queue on the specified device.
1642  */
1643 static int srpt_create_ch_ib(struct srpt_rdma_ch *ch)
1644 {
1645         struct ib_qp_init_attr *qp_init;
1646         struct srpt_device *sdev = ch->sport->sdev;
1647         int cqe;
1648         int ret;
1649
1650         qp_init = kzalloc(sizeof *qp_init, GFP_KERNEL);
1651         if (!qp_init)
1652                 return -ENOMEM;
1653
1654         /* Create a completion queue (CQ). */
1655
1656         cqe = SRPT_RQ_SIZE + SRPT_SQ_SIZE - 1;
1657 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20) && ! defined(RHEL_RELEASE_CODE)
1658         ch->cq = ib_create_cq(sdev->device, srpt_completion, NULL, ch, cqe);
1659 #else
1660         ch->cq = ib_create_cq(sdev->device, srpt_completion, NULL, ch, cqe, 0);
1661 #endif
1662         if (IS_ERR(ch->cq)) {
1663                 ret = PTR_ERR(ch->cq);
1664                 PRINT_ERROR("failed to create_cq cqe= %d ret= %d", cqe, ret);
1665                 goto out;
1666         }
1667
1668         /* Request completion notification. */
1669
1670         ib_req_notify_cq(ch->cq, IB_CQ_NEXT_COMP);
1671
1672         /* Create a queue pair (QP). */
1673
1674         qp_init->qp_context = (void *)ch;
1675         qp_init->event_handler
1676                 = (void(*)(struct ib_event *, void*))srpt_qp_event;
1677         qp_init->send_cq = ch->cq;
1678         qp_init->recv_cq = ch->cq;
1679         qp_init->srq = sdev->srq;
1680         qp_init->sq_sig_type = IB_SIGNAL_REQ_WR;
1681         qp_init->qp_type = IB_QPT_RC;
1682         qp_init->cap.max_send_wr = SRPT_SQ_SIZE;
1683         qp_init->cap.max_send_sge = SRPT_DEF_SG_PER_WQE;
1684
1685         ch->qp = ib_create_qp(sdev->pd, qp_init);
1686         if (IS_ERR(ch->qp)) {
1687                 ret = PTR_ERR(ch->qp);
1688                 ib_destroy_cq(ch->cq);
1689                 PRINT_ERROR("failed to create_qp ret= %d", ret);
1690                 goto out;
1691         }
1692
1693         atomic_set(&ch->qp_wr_avail, qp_init->cap.max_send_wr);
1694
1695         TRACE_DBG("%s: max_cqe= %d max_sge= %d cm_id= %p",
1696                __func__, ch->cq->cqe, qp_init->cap.max_send_sge,
1697                ch->cm_id);
1698
1699         /* Modify the attributes and the state of queue pair ch->qp. */
1700
1701         ret = srpt_init_ch_qp(ch, ch->qp);
1702         if (ret) {
1703                 ib_destroy_qp(ch->qp);
1704                 ib_destroy_cq(ch->cq);
1705                 goto out;
1706         }
1707
1708 out:
1709         kfree(qp_init);
1710         return ret;
1711 }
1712
1713 /**
1714  * Release the channel corresponding to the specified cm_id.
1715  *
1716  * Note: must be called from inside srpt_cm_handler to avoid a race between
1717  * accessing sdev->spinlock and the call to kfree(sdev) in srpt_remove_one()
1718  * (the caller of srpt_cm_handler holds the cm_id spinlock;
1719  * srpt_remove_one() waits until all SCST sessions for the associated
1720  * IB device have been unregistered and SCST session registration involves
1721  * a call to ib_destroy_cm_id(), which locks the cm_id spinlock and hence
1722  * waits until this function has finished).
1723  */
1724 static void srpt_release_channel_by_cmid(struct ib_cm_id *cm_id)
1725 {
1726         struct srpt_device *sdev;
1727         struct srpt_rdma_ch *ch;
1728         bool found;
1729
1730         TRACE_ENTRY();
1731
1732         sdev = cm_id->context;
1733         BUG_ON(!sdev);
1734         found = false;
1735         spin_lock_irq(&sdev->spinlock);
1736         list_for_each_entry(ch, &sdev->rch_list, list) {
1737                 if (ch->cm_id == cm_id) {
1738                         list_del(&ch->list);
1739                         atomic_set(&ch->state, RDMA_CHANNEL_DISCONNECTING);
1740                         found = true;
1741                         break;
1742                 }
1743         }
1744         spin_unlock_irq(&sdev->spinlock);
1745
1746         if (found)
1747                 scst_unregister_session(ch->scst_sess, 0, srpt_release_channel);
1748
1749         TRACE_EXIT();
1750 }
1751
1752 /**
1753  * Look up the RDMA channel that corresponds to the specified cm_id.
1754  *
1755  * Return NULL if no matching RDMA channel has been found.
1756  */
1757 static struct srpt_rdma_ch *srpt_find_channel(struct srpt_device *sdev,
1758                                               struct ib_cm_id *cm_id)
1759 {
1760         struct srpt_rdma_ch *ch;
1761         bool found;
1762
1763         BUG_ON(!sdev);
1764         found = false;
1765         spin_lock_irq(&sdev->spinlock);
1766         list_for_each_entry(ch, &sdev->rch_list, list) {
1767                 if (ch->cm_id == cm_id) {
1768                         found = true;
1769                         break;
1770                 }
1771         }
1772         spin_unlock_irq(&sdev->spinlock);
1773
1774         return found ? ch : NULL;
1775 }
1776
1777 /**
1778  * Release all resources associated with an RDMA channel.
1779  *
1780  * Notes:
1781  * - The caller must have removed the channel from the channel list before
1782  *   calling this function.
1783  * - Must be called as a callback function via scst_unregister_session(). Never
1784  *   call this function directly because doing so would trigger several race
1785  *   conditions.
1786  * - Do not access ch->sport or ch->sport->sdev in this function because the
1787  *   memory that was allocated for the sport and/or sdev data structures may
1788  *   already have been freed at the time this function is called.
1789  */
1790 static void srpt_release_channel(struct scst_session *scst_sess)
1791 {
1792         struct srpt_rdma_ch *ch;
1793
1794         TRACE_ENTRY();
1795
1796         ch = scst_sess_get_tgt_priv(scst_sess);
1797         BUG_ON(!ch);
1798         WARN_ON(atomic_read(&ch->state) != RDMA_CHANNEL_DISCONNECTING);
1799
1800         TRACE_DBG("destroying cm_id %p", ch->cm_id);
1801         BUG_ON(!ch->cm_id);
1802         ib_destroy_cm_id(ch->cm_id);
1803
1804         ib_destroy_qp(ch->qp);
1805         ib_destroy_cq(ch->cq);
1806         kfree(ch);
1807
1808         TRACE_EXIT();
1809 }
1810
1811 /**
1812  * Process the event IB_CM_REQ_RECEIVED.
1813  *
1814  * Ownership of the cm_id is transferred to the SCST session if this functions
1815  * returns zero. Otherwise the caller remains the owner of cm_id.
1816  */
1817 static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
1818                             struct ib_cm_req_event_param *param,
1819                             void *private_data)
1820 {
1821         struct srpt_device *sdev = cm_id->context;
1822         struct srp_login_req *req;
1823         struct srp_login_rsp *rsp;
1824         struct srp_login_rej *rej;
1825         struct ib_cm_rep_param *rep_param;
1826         struct srpt_rdma_ch *ch, *tmp_ch;
1827         u32 it_iu_len;
1828         int ret = 0;
1829
1830 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
1831         WARN_ON(!sdev || !private_data);
1832         if (!sdev || !private_data)
1833                 return -EINVAL;
1834 #else
1835         if (WARN_ON(!sdev || !private_data))
1836                 return -EINVAL;
1837 #endif
1838
1839         req = (struct srp_login_req *)private_data;
1840
1841         it_iu_len = be32_to_cpu(req->req_it_iu_len);
1842
1843         PRINT_INFO("Received SRP_LOGIN_REQ with"
1844             " i_port_id 0x%llx:0x%llx, t_port_id 0x%llx:0x%llx and it_iu_len %d"
1845             " on port %d (guid=0x%llx:0x%llx)",
1846             (unsigned long long)be64_to_cpu(*(u64 *)&req->initiator_port_id[0]),
1847             (unsigned long long)be64_to_cpu(*(u64 *)&req->initiator_port_id[8]),
1848             (unsigned long long)be64_to_cpu(*(u64 *)&req->target_port_id[0]),
1849             (unsigned long long)be64_to_cpu(*(u64 *)&req->target_port_id[8]),
1850             it_iu_len,
1851             param->port,
1852             (unsigned long long)be64_to_cpu(*(u64 *)
1853                                 &sdev->port[param->port - 1].gid.raw[0]),
1854             (unsigned long long)be64_to_cpu(*(u64 *)
1855                                 &sdev->port[param->port - 1].gid.raw[8]));
1856
1857         rsp = kzalloc(sizeof *rsp, GFP_KERNEL);
1858         rej = kzalloc(sizeof *rej, GFP_KERNEL);
1859         rep_param = kzalloc(sizeof *rep_param, GFP_KERNEL);
1860
1861         if (!rsp || !rej || !rep_param) {
1862                 ret = -ENOMEM;
1863                 goto out;
1864         }
1865
1866         if (it_iu_len > srp_max_message_size || it_iu_len < 64) {
1867                 rej->reason =
1868                     cpu_to_be32(SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE);
1869                 ret = -EINVAL;
1870                 PRINT_ERROR("rejected SRP_LOGIN_REQ because its"
1871                             " length (%d bytes) is out of range (%d .. %d)",
1872                             it_iu_len, 64, srp_max_message_size);
1873                 goto reject;
1874         }
1875
1876         if ((req->req_flags & SRP_MTCH_ACTION) == SRP_MULTICHAN_SINGLE) {
1877                 rsp->rsp_flags = SRP_LOGIN_RSP_MULTICHAN_NO_CHAN;
1878
1879                 spin_lock_irq(&sdev->spinlock);
1880
1881                 list_for_each_entry_safe(ch, tmp_ch, &sdev->rch_list, list) {
1882                         if (!memcmp(ch->i_port_id, req->initiator_port_id, 16)
1883                             && !memcmp(ch->t_port_id, req->target_port_id, 16)
1884                             && param->port == ch->sport->port
1885                             && param->listen_id == ch->sport->sdev->cm_id
1886                             && ch->cm_id) {
1887                                 enum rdma_ch_state prev_state;
1888
1889                                 /* found an existing channel */
1890                                 TRACE_DBG("Found existing channel name= %s"
1891                                           " cm_id= %p state= %d",
1892                                           ch->sess_name, ch->cm_id,
1893                                           atomic_read(&ch->state));
1894
1895                                 prev_state = atomic_xchg(&ch->state,
1896                                                 RDMA_CHANNEL_DISCONNECTING);
1897                                 if (prev_state == RDMA_CHANNEL_CONNECTING)
1898                                         list_del(&ch->list);
1899
1900                                 spin_unlock_irq(&sdev->spinlock);
1901
1902                                 rsp->rsp_flags =
1903                                         SRP_LOGIN_RSP_MULTICHAN_TERMINATED;
1904
1905                                 if (prev_state == RDMA_CHANNEL_LIVE) {
1906                                         ib_send_cm_dreq(ch->cm_id, NULL, 0);
1907                                         PRINT_INFO("disconnected"
1908                                           " session %s because a new"
1909                                           " SRP_LOGIN_REQ has been received.",
1910                                           ch->sess_name);
1911                                 } else if (prev_state ==
1912                                          RDMA_CHANNEL_CONNECTING) {
1913                                         PRINT_ERROR("%s", "rejected"
1914                                           " SRP_LOGIN_REQ because another login"
1915                                           " request is being processed.");
1916                                         ib_send_cm_rej(ch->cm_id,
1917                                                        IB_CM_REJ_NO_RESOURCES,
1918                                                        NULL, 0, NULL, 0);
1919                                         scst_unregister_session(ch->scst_sess,
1920                                                         0,
1921                                                         srpt_release_channel);
1922                                 }
1923
1924                                 spin_lock_irq(&sdev->spinlock);
1925                         }
1926                 }
1927
1928                 spin_unlock_irq(&sdev->spinlock);
1929
1930         } else
1931                 rsp->rsp_flags = SRP_LOGIN_RSP_MULTICHAN_MAINTAINED;
1932
1933         if (((u64) (*(u64 *) req->target_port_id) !=
1934              cpu_to_be64(srpt_service_guid)) ||
1935             ((u64) (*(u64 *) (req->target_port_id + 8)) !=
1936              cpu_to_be64(srpt_service_guid))) {
1937                 rej->reason =
1938                     cpu_to_be32(SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL);
1939                 ret = -ENOMEM;
1940                 PRINT_ERROR("%s", "rejected SRP_LOGIN_REQ because it"
1941                        " has an invalid target port identifier.");
1942                 goto reject;
1943         }
1944
1945         ch = kzalloc(sizeof *ch, GFP_KERNEL);
1946         if (!ch) {
1947                 rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
1948                 PRINT_ERROR("%s",
1949                             "rejected SRP_LOGIN_REQ because out of memory.");
1950                 ret = -ENOMEM;
1951                 goto reject;
1952         }
1953
1954         memcpy(ch->i_port_id, req->initiator_port_id, 16);
1955         memcpy(ch->t_port_id, req->target_port_id, 16);
1956         ch->sport = &sdev->port[param->port - 1];
1957         ch->cm_id = cm_id;
1958         atomic_set(&ch->state, RDMA_CHANNEL_CONNECTING);
1959         INIT_LIST_HEAD(&ch->cmd_wait_list);
1960
1961         ret = srpt_create_ch_ib(ch);
1962         if (ret) {
1963                 rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
1964                 PRINT_ERROR("%s", "rejected SRP_LOGIN_REQ because creating"
1965                             " a new RDMA channel failed.");
1966                 goto free_ch;
1967         }
1968
1969         ret = srpt_ch_qp_rtr(ch, ch->qp);
1970         if (ret) {
1971                 rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
1972                 PRINT_ERROR("rejected SRP_LOGIN_REQ because enabling"
1973                        " RTR failed (error code = %d)", ret);
1974                 goto destroy_ib;
1975         }
1976
1977         if (use_port_guid_in_session_name) {
1978                 /*
1979                  * If the kernel module parameter use_port_guid_in_session_name
1980                  * has been specified, use a combination of the target port
1981                  * GUID and the initiator port ID as the session name. This
1982                  * was the original behavior of the SRP target implementation
1983                  * (i.e. before the SRPT was included in OFED 1.3).
1984                  */
1985                 snprintf(ch->sess_name, sizeof(ch->sess_name),
1986                          "0x%016llx%016llx",
1987                          (unsigned long long)be64_to_cpu(*(u64 *)
1988                                 &sdev->port[param->port - 1].gid.raw[8]),
1989                          (unsigned long long)be64_to_cpu(*(u64 *)
1990                                 (ch->i_port_id + 8)));
1991         } else {
1992                 /*
1993                  * Default behavior: use the initator port identifier as the
1994                  * session name.
1995                  */
1996                 snprintf(ch->sess_name, sizeof(ch->sess_name),
1997                          "0x%016llx%016llx",
1998                          (unsigned long long)be64_to_cpu(*(u64 *)ch->i_port_id),
1999                          (unsigned long long)be64_to_cpu(*(u64 *)
2000                                  (ch->i_port_id + 8)));
2001         }
2002
2003         TRACE_DBG("registering session %s", ch->sess_name);
2004
2005         BUG_ON(!sdev->scst_tgt);
2006         ch->scst_sess = scst_register_session(sdev->scst_tgt, 0, ch->sess_name,
2007                                               NULL, NULL);
2008         if (!ch->scst_sess) {
2009                 rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
2010                 TRACE_DBG("%s", "Failed to create scst sess");
2011                 goto destroy_ib;
2012         }
2013
2014         TRACE_DBG("Establish connection sess=%p name=%s cm_id=%p",
2015                   ch->scst_sess, ch->sess_name, ch->cm_id);
2016
2017         scst_sess_set_tgt_priv(ch->scst_sess, ch);
2018
2019         /* create srp_login_response */
2020         rsp->opcode = SRP_LOGIN_RSP;
2021         rsp->tag = req->tag;
2022         rsp->max_it_iu_len = req->req_it_iu_len;
2023         rsp->max_ti_iu_len = req->req_it_iu_len;
2024         ch->max_ti_iu_len = req->req_it_iu_len;
2025         rsp->buf_fmt =
2026             cpu_to_be16(SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT);
2027         rsp->req_lim_delta = cpu_to_be32(SRPT_RQ_SIZE);
2028         atomic_set(&ch->req_lim, SRPT_RQ_SIZE);
2029         atomic_set(&ch->last_response_req_lim, SRPT_RQ_SIZE);
2030
2031         /* create cm reply */
2032         rep_param->qp_num = ch->qp->qp_num;
2033         rep_param->private_data = (void *)rsp;
2034         rep_param->private_data_len = sizeof *rsp;
2035         rep_param->rnr_retry_count = 7;
2036         rep_param->flow_control = 1;
2037         rep_param->failover_accepted = 0;
2038         rep_param->srq = 1;
2039         rep_param->responder_resources = 4;
2040         rep_param->initiator_depth = 4;
2041
2042         ret = ib_send_cm_rep(cm_id, rep_param);
2043         if (ret) {
2044                 PRINT_ERROR("sending SRP_LOGIN_REQ response failed"
2045                             " (error code = %d)", ret);
2046                 goto release_channel;
2047         }
2048
2049         spin_lock_irq(&sdev->spinlock);
2050         list_add_tail(&ch->list, &sdev->rch_list);
2051         spin_unlock_irq(&sdev->spinlock);
2052
2053         goto out;
2054
2055 release_channel:
2056         atomic_set(&ch->state, RDMA_CHANNEL_DISCONNECTING);
2057         scst_unregister_session(ch->scst_sess, 0, NULL);
2058         ch->scst_sess = NULL;
2059
2060 destroy_ib:
2061         ib_destroy_qp(ch->qp);
2062         ib_destroy_cq(ch->cq);
2063
2064 free_ch:
2065         kfree(ch);
2066
2067 reject:
2068         rej->opcode = SRP_LOGIN_REJ;
2069         rej->tag = req->tag;
2070         rej->buf_fmt =
2071             cpu_to_be16(SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT);
2072
2073         ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED, NULL, 0,
2074                              (void *)rej, sizeof *rej);
2075
2076 out:
2077         kfree(rep_param);
2078         kfree(rsp);
2079         kfree(rej);
2080
2081         return ret;
2082 }
2083
2084 static void srpt_cm_rej_recv(struct ib_cm_id *cm_id)
2085 {
2086         PRINT_INFO("Received InfiniBand REJ packet for cm_id %p.", cm_id);
2087         srpt_release_channel_by_cmid(cm_id);
2088 }
2089
2090 /**
2091  * Process an IB_CM_RTU_RECEIVED or IB_CM_USER_ESTABLISHED event.
2092  *
2093  * An IB_CM_RTU_RECEIVED message indicates that the connection is established
2094  * and that the recipient may begin transmitting (RTU = ready to use).
2095  */
2096 static void srpt_cm_rtu_recv(struct ib_cm_id *cm_id)
2097 {
2098         struct srpt_rdma_ch *ch;
2099         int ret;
2100
2101         ch = srpt_find_channel(cm_id->context, cm_id);
2102         WARN_ON(!ch);
2103         if (!ch)
2104                 goto out;
2105
2106         if (srpt_test_and_set_channel_state(ch, RDMA_CHANNEL_CONNECTING,
2107                         RDMA_CHANNEL_LIVE) == RDMA_CHANNEL_CONNECTING) {
2108                 struct srpt_ioctx *ioctx, *ioctx_tmp;
2109
2110                 ret = srpt_ch_qp_rts(ch, ch->qp);
2111
2112                 list_for_each_entry_safe(ioctx, ioctx_tmp, &ch->cmd_wait_list,
2113                                          wait_list) {
2114                         list_del(&ioctx->wait_list);
2115                         srpt_handle_new_iu(ch, ioctx);
2116                 }
2117                 if (ret && srpt_test_and_set_channel_state(ch,
2118                         RDMA_CHANNEL_LIVE,
2119                         RDMA_CHANNEL_DISCONNECTING) == RDMA_CHANNEL_LIVE) {
2120                         TRACE_DBG("cm_id=%p sess_name=%s state=%d",
2121                                   cm_id, ch->sess_name,
2122                                   atomic_read(&ch->state));
2123                         ib_send_cm_dreq(ch->cm_id, NULL, 0);
2124                 }
2125         }
2126
2127 out:
2128         ;
2129 }
2130
2131 static void srpt_cm_timewait_exit(struct ib_cm_id *cm_id)
2132 {
2133         PRINT_INFO("Received InfiniBand TimeWait exit for cm_id %p.", cm_id);
2134         srpt_release_channel_by_cmid(cm_id);
2135 }
2136
2137 static void srpt_cm_rep_error(struct ib_cm_id *cm_id)
2138 {
2139         PRINT_INFO("Received InfiniBand REP error for cm_id %p.", cm_id);
2140         srpt_release_channel_by_cmid(cm_id);
2141 }
2142
2143 static void srpt_cm_dreq_recv(struct ib_cm_id *cm_id)
2144 {
2145         struct srpt_rdma_ch *ch;
2146
2147         ch = srpt_find_channel(cm_id->context, cm_id);
2148         if (!ch) {
2149                 TRACE_DBG("Received DREQ for channel %p which is already"
2150                           " being unregistered.", cm_id);
2151                 goto out;
2152         }
2153
2154         TRACE_DBG("cm_id= %p ch->state= %d", cm_id, atomic_read(&ch->state));
2155
2156         switch (atomic_read(&ch->state)) {
2157         case RDMA_CHANNEL_LIVE:
2158         case RDMA_CHANNEL_CONNECTING:
2159                 ib_send_cm_drep(ch->cm_id, NULL, 0);
2160                 PRINT_INFO("Received DREQ and sent DREP for session %s.",
2161                            ch->sess_name);
2162                 break;
2163         case RDMA_CHANNEL_DISCONNECTING:
2164         default:
2165                 break;
2166         }
2167
2168 out:
2169         ;
2170 }
2171
2172 static void srpt_cm_drep_recv(struct ib_cm_id *cm_id)
2173 {
2174         PRINT_INFO("Received InfiniBand DREP message for cm_id %p.", cm_id);
2175         srpt_release_channel_by_cmid(cm_id);
2176 }
2177
2178 /**
2179  * IB connection manager callback function.
2180  *
2181  * A non-zero return value will cause the caller destroy the CM ID.
2182  *
2183  * Note: srpt_cm_handler() must only return a non-zero value when transferring
2184  * ownership of the cm_id to a channel by srpt_cm_req_recv() failed. Returning
2185  * a non-zero value in any other case will trigger a race with the
2186  * ib_destroy_cm_id() call in srpt_release_channel().
2187  */
2188 static int srpt_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
2189 {
2190         int ret;
2191
2192         ret = 0;
2193         switch (event->event) {
2194         case IB_CM_REQ_RECEIVED:
2195                 ret = srpt_cm_req_recv(cm_id, &event->param.req_rcvd,
2196                                        event->private_data);
2197                 break;
2198         case IB_CM_REJ_RECEIVED:
2199                 srpt_cm_rej_recv(cm_id);
2200                 break;
2201         case IB_CM_RTU_RECEIVED:
2202         case IB_CM_USER_ESTABLISHED:
2203                 srpt_cm_rtu_recv(cm_id);
2204                 break;
2205         case IB_CM_DREQ_RECEIVED:
2206                 srpt_cm_dreq_recv(cm_id);
2207                 break;
2208         case IB_CM_DREP_RECEIVED:
2209                 srpt_cm_drep_recv(cm_id);
2210                 break;
2211         case IB_CM_TIMEWAIT_EXIT:
2212                 srpt_cm_timewait_exit(cm_id);
2213                 break;
2214         case IB_CM_REP_ERROR:
2215                 srpt_cm_rep_error(cm_id);
2216                 break;
2217         default:
2218                 PRINT_ERROR("received unrecognized IB CM event %d",
2219                             event->event);
2220                 break;
2221         }
2222
2223         return ret;
2224 }
2225
2226 static int srpt_map_sg_to_ib_sge(struct srpt_rdma_ch *ch,
2227                                  struct srpt_ioctx *ioctx,
2228                                  struct scst_cmd *scmnd)
2229 {
2230         struct scatterlist *scat;
2231         scst_data_direction dir;
2232         struct rdma_iu *riu;
2233         struct srp_direct_buf *db;
2234         dma_addr_t dma_addr;
2235         struct ib_sge *sge;
2236         u64 raddr;
2237         u32 rsize;
2238         u32 tsize;
2239         u32 dma_len;
2240         int count, nrdma;
2241         int i, j, k;
2242
2243         BUG_ON(!ch);
2244         BUG_ON(!ioctx);
2245         BUG_ON(!scmnd);
2246         scat = scst_cmd_get_sg(scmnd);
2247         WARN_ON(!scat);
2248         dir = scst_cmd_get_data_direction(scmnd);
2249         count = ib_dma_map_sg(ch->sport->sdev->device, scat,
2250                               scst_cmd_get_sg_cnt(scmnd),
2251                               scst_to_tgt_dma_dir(dir));
2252         if (unlikely(!count))
2253                 return -EBUSY;
2254
2255         ioctx->mapped_sg_count = count;
2256
2257         if (ioctx->rdma_ius && ioctx->n_rdma_ius)
2258                 nrdma = ioctx->n_rdma_ius;
2259         else {
2260                 nrdma = count / SRPT_DEF_SG_PER_WQE + ioctx->n_rbuf;
2261
2262                 ioctx->rdma_ius = kzalloc(nrdma * sizeof *riu,
2263                                           scst_cmd_atomic(scmnd)
2264                                           ? GFP_ATOMIC : GFP_KERNEL);
2265                 if (!ioctx->rdma_ius)
2266                         goto free_mem;
2267
2268                 ioctx->n_rdma_ius = nrdma;
2269         }
2270
2271         db = ioctx->rbufs;
2272         tsize = (dir == SCST_DATA_READ) ?
2273                 scst_cmd_get_resp_data_len(scmnd) : scst_cmd_get_bufflen(scmnd);
2274         dma_len = sg_dma_len(&scat[0]);
2275         riu = ioctx->rdma_ius;
2276
2277         /*
2278          * For each remote desc - calculate the #ib_sge.
2279          * If #ib_sge < SRPT_DEF_SG_PER_WQE per rdma operation then
2280          *      each remote desc rdma_iu is required a rdma wr;
2281          * else
2282          *      we need to allocate extra rdma_iu to carry extra #ib_sge in
2283          *      another rdma wr
2284          */
2285         for (i = 0, j = 0;
2286              j < count && i < ioctx->n_rbuf && tsize > 0; ++i, ++riu, ++db) {
2287                 rsize = be32_to_cpu(db->len);
2288                 raddr = be64_to_cpu(db->va);
2289                 riu->raddr = raddr;
2290                 riu->rkey = be32_to_cpu(db->key);
2291                 riu->sge_cnt = 0;
2292
2293                 /* calculate how many sge required for this remote_buf */
2294                 while (rsize > 0 && tsize > 0) {
2295
2296                         if (rsize >= dma_len) {
2297                                 tsize -= dma_len;
2298                                 rsize -= dma_len;
2299                                 raddr += dma_len;
2300
2301                                 if (tsize > 0) {
2302                                         ++j;
2303                                         if (j < count)
2304                                                 dma_len = sg_dma_len(&scat[j]);
2305                                 }
2306                         } else {
2307                                 tsize -= rsize;
2308                                 dma_len -= rsize;
2309                                 rsize = 0;
2310                         }
2311
2312                         ++riu->sge_cnt;
2313
2314                         if (rsize > 0 && riu->sge_cnt == SRPT_DEF_SG_PER_WQE) {
2315                                 ++ioctx->n_rdma;
2316                                 riu->sge =
2317                                     kmalloc(riu->sge_cnt * sizeof *riu->sge,
2318                                             scst_cmd_atomic(scmnd)
2319                                             ? GFP_ATOMIC : GFP_KERNEL);
2320                                 if (!riu->sge)
2321                                         goto free_mem;
2322
2323                                 ++riu;
2324                                 riu->sge_cnt = 0;
2325                                 riu->raddr = raddr;
2326                                 riu->rkey = be32_to_cpu(db->key);
2327                         }
2328                 }
2329
2330                 ++ioctx->n_rdma;
2331                 riu->sge = kmalloc(riu->sge_cnt * sizeof *riu->sge,
2332                                    scst_cmd_atomic(scmnd)
2333                                    ? GFP_ATOMIC : GFP_KERNEL);
2334                 if (!riu->sge)
2335                         goto free_mem;
2336         }
2337
2338         db = ioctx->rbufs;
2339         scat = scst_cmd_get_sg(scmnd);
2340         tsize = (dir == SCST_DATA_READ) ?
2341                 scst_cmd_get_resp_data_len(scmnd) : scst_cmd_get_bufflen(scmnd);
2342         riu = ioctx->rdma_ius;
2343         dma_len = sg_dma_len(&scat[0]);
2344         dma_addr = sg_dma_address(&scat[0]);
2345
2346         /* this second loop is really mapped sg_addres to rdma_iu->ib_sge */
2347         for (i = 0, j = 0;
2348              j < count && i < ioctx->n_rbuf && tsize > 0; ++i, ++riu, ++db) {
2349                 rsize = be32_to_cpu(db->len);
2350                 sge = riu->sge;
2351                 k = 0;
2352
2353                 while (rsize > 0 && tsize > 0) {
2354                         sge->addr = dma_addr;
2355                         sge->lkey = ch->sport->sdev->mr->lkey;
2356
2357                         if (rsize >= dma_len) {
2358                                 sge->length =
2359                                         (tsize < dma_len) ? tsize : dma_len;
2360                                 tsize -= dma_len;
2361                                 rsize -= dma_len;
2362
2363                                 if (tsize > 0) {
2364                                         ++j;
2365                                         if (j < count) {
2366                                                 dma_len = sg_dma_len(&scat[j]);
2367                                                 dma_addr =
2368                                                     sg_dma_address(&scat[j]);
2369                                         }
2370                                 }
2371                         } else {
2372                                 sge->length = (tsize < rsize) ? tsize : rsize;
2373                                 tsize -= rsize;
2374                                 dma_len -= rsize;
2375                                 dma_addr += rsize;
2376                                 rsize = 0;
2377                         }
2378
2379                         ++k;
2380                         if (k == riu->sge_cnt && rsize > 0) {
2381                                 ++riu;
2382                                 sge = riu->sge;
2383                                 k = 0;
2384                         } else if (rsize > 0)
2385                                 ++sge;
2386                 }
2387         }
2388
2389         return 0;
2390
2391 free_mem:
2392         srpt_unmap_sg_to_ib_sge(ch, ioctx);
2393
2394         return -ENOMEM;
2395 }
2396
2397 static void srpt_unmap_sg_to_ib_sge(struct srpt_rdma_ch *ch,
2398                                     struct srpt_ioctx *ioctx)
2399 {
2400         struct scst_cmd *scmnd;
2401         struct scatterlist *scat;
2402         scst_data_direction dir;
2403
2404         BUG_ON(!ch);
2405         BUG_ON(!ioctx);
2406         BUG_ON(ioctx->n_rdma && !ioctx->rdma_ius);
2407
2408         while (ioctx->n_rdma)
2409                 kfree(ioctx->rdma_ius[--ioctx->n_rdma].sge);
2410
2411         kfree(ioctx->rdma_ius);
2412         ioctx->rdma_ius = NULL;
2413
2414         if (ioctx->mapped_sg_count) {
2415                 scmnd = ioctx->scmnd;
2416                 BUG_ON(!scmnd);
2417                 WARN_ON(ioctx->scmnd != scmnd);
2418                 WARN_ON(ioctx != scst_cmd_get_tgt_priv(scmnd));
2419                 scat = scst_cmd_get_sg(scmnd);
2420                 WARN_ON(!scat);
2421                 dir = scst_cmd_get_data_direction(scmnd);
2422                 WARN_ON(dir == SCST_DATA_NONE);
2423                 ib_dma_unmap_sg(ch->sport->sdev->device, scat,
2424                                 scst_cmd_get_sg_cnt(scmnd),
2425                                 scst_to_tgt_dma_dir(dir));
2426                 ioctx->mapped_sg_count = 0;
2427         }
2428 }
2429
2430 static int srpt_perform_rdmas(struct srpt_rdma_ch *ch, struct srpt_ioctx *ioctx,
2431                               scst_data_direction dir)
2432 {
2433         struct ib_send_wr wr;
2434         struct ib_send_wr *bad_wr;
2435         struct rdma_iu *riu;
2436         int i;
2437         int ret;
2438         int srq_wr_avail;
2439
2440         if (dir == SCST_DATA_WRITE) {
2441                 ret = -ENOMEM;
2442                 srq_wr_avail = atomic_sub_return(ioctx->n_rdma,
2443                                                  &ch->qp_wr_avail);
2444                 if (srq_wr_avail < 0) {
2445                         atomic_add(ioctx->n_rdma, &ch->qp_wr_avail);
2446                         PRINT_INFO("%s[%d]: SRQ full", __func__, __LINE__);
2447                         goto out;
2448                 }
2449         }
2450
2451         ret = 0;
2452         riu = ioctx->rdma_ius;
2453         memset(&wr, 0, sizeof wr);
2454
2455         for (i = 0; i < ioctx->n_rdma; ++i, ++riu) {
2456                 wr.opcode = (dir == SCST_DATA_READ) ?
2457                     IB_WR_RDMA_WRITE : IB_WR_RDMA_READ;
2458                 wr.next = NULL;
2459                 wr.wr_id = ioctx->index;
2460                 wr.wr.rdma.remote_addr = riu->raddr;
2461                 wr.wr.rdma.rkey = riu->rkey;
2462                 wr.num_sge = riu->sge_cnt;
2463                 wr.sg_list = riu->sge;
2464
2465                 /* only get completion event for the last rdma wr */
2466                 if (i == (ioctx->n_rdma - 1) && dir == SCST_DATA_WRITE)
2467                         wr.send_flags = IB_SEND_SIGNALED;
2468
2469                 ret = ib_post_send(ch->qp, &wr, &bad_wr);
2470                 if (ret)
2471                         goto out;
2472         }
2473
2474 out:
2475         return ret;
2476 }
2477
2478 /*
2479  * Start data transfer between initiator and target. Must not block.
2480  */
2481 static int srpt_xfer_data(struct srpt_rdma_ch *ch, struct srpt_ioctx *ioctx,
2482                           struct scst_cmd *scmnd)
2483 {
2484         int ret;
2485
2486         ret = srpt_map_sg_to_ib_sge(ch, ioctx, scmnd);
2487         if (ret) {
2488                 PRINT_ERROR("%s[%d] ret=%d", __func__, __LINE__, ret);
2489                 ret = SCST_TGT_RES_QUEUE_FULL;
2490                 goto out;
2491         }
2492
2493         ret = srpt_perform_rdmas(ch, ioctx, scst_cmd_get_data_direction(scmnd));
2494         if (ret) {
2495                 if (ret == -EAGAIN || ret == -ENOMEM) {
2496                         PRINT_INFO("%s[%d] queue full -- ret=%d",
2497                                    __func__, __LINE__, ret);
2498                         ret = SCST_TGT_RES_QUEUE_FULL;
2499                 } else {
2500                         PRINT_ERROR("%s[%d] fatal error -- ret=%d",
2501                                     __func__, __LINE__, ret);
2502                         ret = SCST_TGT_RES_FATAL_ERROR;
2503                 }
2504                 goto out_unmap;
2505         }
2506
2507         ret = SCST_TGT_RES_SUCCESS;
2508
2509 out:
2510         return ret;
2511 out_unmap:
2512         srpt_unmap_sg_to_ib_sge(ch, ioctx);
2513         goto out;
2514 }
2515
2516 /*
2517  * Called by the SCST core to inform ib_srpt that data reception from the
2518  * initiator should start (SCST_DATA_WRITE). Must not block.
2519  */
2520 static int srpt_rdy_to_xfer(struct scst_cmd *scmnd)
2521 {
2522         struct srpt_rdma_ch *ch;
2523         struct srpt_ioctx *ioctx;
2524         enum rdma_ch_state ch_state;
2525         int ret;
2526
2527         ioctx = scst_cmd_get_tgt_priv(scmnd);
2528         BUG_ON(!ioctx);
2529
2530         WARN_ON(srpt_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA)
2531                 == SRPT_STATE_DONE);
2532
2533         ch = ioctx->ch;
2534         WARN_ON(ch != scst_sess_get_tgt_priv(scst_cmd_get_session(scmnd)));
2535         BUG_ON(!ch);
2536
2537         ch_state = atomic_read(&ch->state);
2538         if (ch_state == RDMA_CHANNEL_DISCONNECTING) {
2539                 TRACE_DBG("cmd with tag %lld: channel disconnecting",
2540                           scst_cmd_get_tag(scmnd));
2541                 ret = SCST_TGT_RES_FATAL_ERROR;
2542                 goto out;
2543         } else if (ch_state == RDMA_CHANNEL_CONNECTING) {
2544                 ret = SCST_TGT_RES_QUEUE_FULL;
2545                 goto out;
2546         }
2547         ret = srpt_xfer_data(ch, ioctx, scmnd);
2548
2549 out:
2550         return ret;
2551 }
2552
2553 /**
2554  * srpt_must_wait_for_cred() - Whether or not the target must wait with
2555  * sending a response towards the initiator in order to avoid that the
2556  * initiator locks up. The Linux SRP initiator locks up when:
2557  * initiator.req_lim < req_lim_min (2 for SRP_CMD; 1 for SRP_TSK_MGMT).
2558  * no new SRP_RSP is received, or new SRP_RSP do not increase initiator.req_lim.
2559  * In order to avoid an initiator lock up, the target must not send an SRP_RSP
2560  * that keeps initiator.req_lim < req_lim_min when initiator.req_lim
2561  * < req_lim_min. when target.req_lim == req_lim_min - 1, initiator.req_lim must
2562  * also equal req_lim_min - 1 because of the credit mechanism defined in the
2563  * SRP standard. Hence wait with sending a response if that response would not
2564  * increase initiator.req_lim.
2565  */
2566 static bool srpt_must_wait_for_cred(struct srpt_rdma_ch *ch, int req_lim_min)
2567 {
2568         int req_lim;
2569         req_lim = atomic_read(&ch->req_lim);
2570
2571         return req_lim < req_lim_min
2572                 && req_lim - atomic_read(&ch->last_response_req_lim) + 1 <= 0;
2573 }
2574
2575 static void srpt_wait_for_cred(struct srpt_rdma_ch *ch, int req_lim_min)
2576 {
2577         while (unlikely(srpt_must_wait_for_cred(ch, req_lim_min)))
2578                 schedule();
2579 }
2580
2581 /**
2582  * srpt_xmit_response() - SCST callback function that transmits the response
2583  * to a SCSI command.
2584  *
2585  * Must not block.
2586  */
2587 static int srpt_xmit_response(struct scst_cmd *scmnd)
2588 {
2589         struct srpt_rdma_ch *ch;
2590         struct srpt_ioctx *ioctx;
2591         s32 req_lim_delta;
2592         int ret = SCST_TGT_RES_SUCCESS;
2593         int dir;
2594         int resp_len;
2595
2596         ioctx = scst_cmd_get_tgt_priv(scmnd);
2597         BUG_ON(!ioctx);
2598
2599         ch = scst_sess_get_tgt_priv(scst_cmd_get_session(scmnd));
2600         BUG_ON(!ch);
2601
2602         if (unlikely(scst_cmd_aborted(scmnd))) {
2603                 TRACE_DBG("cmd with tag %lld has been aborted",
2604                           scst_cmd_get_tag(scmnd));
2605                 srpt_abort_scst_cmd(ioctx, SCST_CONTEXT_SAME);
2606                 ret = SCST_TGT_RES_SUCCESS;
2607                 goto out;
2608         }
2609
2610         if (unlikely(scst_cmd_atomic(scmnd))) {
2611                 TRACE_DBG("%s", "Switching to thread context.");
2612                 ret = SCST_TGT_RES_NEED_THREAD_CTX;
2613                 goto out;
2614         }
2615
2616         srpt_wait_for_cred(ch, 2);
2617
2618         WARN_ON(srpt_set_cmd_state(ioctx, SRPT_STATE_CMD_RSP_SENT)
2619                 == SRPT_STATE_DONE);
2620
2621         dir = scst_cmd_get_data_direction(scmnd);
2622
2623         /* For read commands, transfer the data to the initiator. */
2624         if (dir == SCST_DATA_READ && scst_cmd_get_resp_data_len(scmnd)) {
2625                 ret = srpt_xfer_data(ch, ioctx, scmnd);
2626                 if (ret != SCST_TGT_RES_SUCCESS) {
2627                         PRINT_ERROR("%s: tag= %lld xfer_data failed",
2628                                     __func__,
2629                                     (unsigned long long)
2630                                     scst_cmd_get_tag(scmnd));
2631                         goto out;
2632                 }
2633         }
2634
2635         scst_check_convert_sense(scmnd);
2636
2637         req_lim_delta = srpt_req_lim_delta(ch) + 1;
2638         resp_len = srpt_build_cmd_rsp(ch, ioctx, req_lim_delta,
2639                                       scst_cmd_get_tag(scmnd),
2640                                       scst_cmd_get_status(scmnd),
2641                                       scst_cmd_get_sense_buffer(scmnd),
2642                                       scst_cmd_get_sense_buffer_len(scmnd));
2643
2644         if (srpt_post_send(ch, ioctx, resp_len)) {
2645                 srpt_unmap_sg_to_ib_sge(ch, ioctx);
2646                 srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
2647                 scst_set_delivery_status(scmnd, SCST_CMD_DELIVERY_FAILED);
2648                 scst_tgt_cmd_done(scmnd, SCST_CONTEXT_SAME);
2649                 PRINT_ERROR("%s[%d]: ch->state= %d tag= %lld",
2650                             __func__, __LINE__, atomic_read(&ch->state),
2651                             (unsigned long long)scst_cmd_get_tag(scmnd));
2652                 atomic_sub(req_lim_delta, &ch->last_response_req_lim);
2653                 ret = SCST_TGT_RES_FATAL_ERROR;
2654         }
2655
2656 out:
2657         return ret;
2658 }
2659
2660 /**
2661  * srpt_tsk_mgmt_done() - SCST callback function that sends back the response
2662  * for a task management request.
2663  *
2664  * Must not block.
2665  */
2666 static void srpt_tsk_mgmt_done(struct scst_mgmt_cmd *mcmnd)
2667 {
2668         struct srpt_rdma_ch *ch;
2669         struct srpt_mgmt_ioctx *mgmt_ioctx;
2670         struct srpt_ioctx *ioctx;
2671         s32 req_lim_delta;
2672         int rsp_len;
2673
2674         mgmt_ioctx = scst_mgmt_cmd_get_tgt_priv(mcmnd);
2675         BUG_ON(!mgmt_ioctx);
2676
2677         ch = mgmt_ioctx->ch;
2678         BUG_ON(!ch);
2679
2680         ioctx = mgmt_ioctx->ioctx;
2681         BUG_ON(!ioctx);
2682
2683         TRACE_DBG("%s: tsk_mgmt_done for tag= %lld status=%d",
2684                   __func__, (unsigned long long)mgmt_ioctx->tag,
2685                   scst_mgmt_cmd_get_status(mcmnd));
2686
2687         WARN_ON(in_irq());
2688
2689         srpt_wait_for_cred(ch, 1);
2690
2691         WARN_ON(srpt_set_cmd_state(ioctx, SRPT_STATE_MGMT_RSP_SENT)
2692                 == SRPT_STATE_DONE);
2693
2694         req_lim_delta = srpt_req_lim_delta(ch) + 1;
2695         rsp_len = srpt_build_tskmgmt_rsp(ch, ioctx, req_lim_delta,
2696                                          (scst_mgmt_cmd_get_status(mcmnd) ==
2697                                           SCST_MGMT_STATUS_SUCCESS) ?
2698                                          SRP_TSK_MGMT_SUCCESS :
2699                                          SRP_TSK_MGMT_FAILED,
2700                                          mgmt_ioctx->tag);
2701         /*
2702          * Note: the srpt_post_send() call below sends the task management
2703          * response asynchronously. It is possible that the SCST core has
2704          * already freed the struct scst_mgmt_cmd structure before the
2705          * response is sent. This is fine.
2706          */
2707         if (srpt_post_send(ch, ioctx, rsp_len)) {
2708                 PRINT_ERROR("%s", "Sending SRP_RSP response failed.");
2709                 atomic_sub(req_lim_delta, &ch->last_response_req_lim);
2710         }
2711
2712         scst_mgmt_cmd_set_tgt_priv(mcmnd, NULL);
2713
2714         kfree(mgmt_ioctx);
2715 }
2716
2717 /*
2718  * Called by the SCST core to inform ib_srpt that the command 'scmnd' is about
2719  * to be freed. May be called in IRQ context.
2720  */
2721 static void srpt_on_free_cmd(struct scst_cmd *scmnd)
2722 {
2723         struct srpt_rdma_ch *ch;
2724         struct srpt_ioctx *ioctx;
2725
2726         ioctx = scst_cmd_get_tgt_priv(scmnd);
2727         BUG_ON(!ioctx);
2728
2729         WARN_ON(srpt_get_cmd_state(ioctx) != SRPT_STATE_DONE);
2730
2731         ch = ioctx->ch;
2732         BUG_ON(!ch);
2733
2734         srpt_reset_ioctx(ch, ioctx);
2735
2736         scst_cmd_set_tgt_priv(scmnd, NULL);
2737         ioctx->scmnd = NULL;
2738         ioctx->ch = NULL;
2739 }
2740
2741 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20) && ! defined(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19)
2742 /* A vanilla 2.6.19 or older kernel without backported OFED kernel headers. */
2743 static void srpt_refresh_port_work(void *ctx)
2744 #else
2745 static void srpt_refresh_port_work(struct work_struct *work)
2746 #endif
2747 {
2748 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20) && ! defined(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19)
2749         struct srpt_port *sport = (struct srpt_port *)ctx;
2750 #else
2751         struct srpt_port *sport = container_of(work, struct srpt_port, work);
2752 #endif
2753
2754         srpt_refresh_port(sport);
2755 }
2756
2757 /*
2758  * Called by the SCST core to detect target adapters. Returns the number of
2759  * detected target adapters.
2760  */
2761 static int srpt_detect(struct scst_tgt_template *tp)
2762 {
2763         int device_count;
2764
2765         TRACE_ENTRY();
2766
2767         device_count = atomic_read(&srpt_device_count);
2768
2769         TRACE_EXIT_RES(device_count);
2770
2771         return device_count;
2772 }
2773
2774 /*
2775  * Callback function called by the SCST core from scst_unregister() to free up
2776  * the resources associated with device scst_tgt.
2777  */
2778 static int srpt_release(struct scst_tgt *scst_tgt)
2779 {
2780         struct srpt_device *sdev = scst_tgt_get_tgt_priv(scst_tgt);
2781         struct srpt_rdma_ch *ch, *tmp_ch;
2782
2783         TRACE_ENTRY();
2784
2785         BUG_ON(!scst_tgt);
2786 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
2787         WARN_ON(!sdev);
2788         if (!sdev)
2789                 return -ENODEV;
2790 #else
2791         if (WARN_ON(!sdev))
2792                 return -ENODEV;
2793 #endif
2794
2795 #ifdef CONFIG_SCST_PROC
2796         srpt_unregister_procfs_entry(scst_tgt->tgtt);
2797 #endif /*CONFIG_SCST_PROC*/
2798
2799         spin_lock_irq(&sdev->spinlock);
2800         list_for_each_entry_safe(ch, tmp_ch, &sdev->rch_list, list) {
2801                 list_del(&ch->list);
2802                 atomic_set(&ch->state, RDMA_CHANNEL_DISCONNECTING);
2803                 spin_unlock_irq(&sdev->spinlock);
2804                 scst_unregister_session(ch->scst_sess, true,
2805                                         srpt_release_channel);
2806                 spin_lock_irq(&sdev->spinlock);
2807         }
2808         spin_unlock_irq(&sdev->spinlock);
2809
2810         scst_tgt_set_tgt_priv(scst_tgt, NULL);
2811
2812         TRACE_EXIT();
2813
2814         return 0;
2815 }
2816
2817 /* SCST target template for the SRP target implementation. */
2818 static struct scst_tgt_template srpt_template = {
2819         .name = DRV_NAME,
2820         .sg_tablesize = SRPT_DEF_SG_TABLESIZE,
2821         .detect = srpt_detect,
2822         .release = srpt_release,
2823         .xmit_response = srpt_xmit_response,
2824         .rdy_to_xfer = srpt_rdy_to_xfer,
2825         .on_free_cmd = srpt_on_free_cmd,
2826         .task_mgmt_fn_done = srpt_tsk_mgmt_done
2827 };
2828
2829 /*
2830  * The callback function srpt_release_class_dev() is called whenever a
2831  * device is removed from the /sys/class/infiniband_srpt device class.
2832  * Although this function has been left empty, a release function has been
2833  * defined such that upon module removal no complaint is logged about a
2834  * missing release function.
2835  */
2836 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2837 static void srpt_release_class_dev(struct class_device *class_dev)
2838 #else
2839 static void srpt_release_class_dev(struct device *dev)
2840 #endif
2841 {
2842 }
2843
2844 #ifdef CONFIG_SCST_PROC
2845
2846 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
2847 static int srpt_trace_level_show(struct seq_file *seq, void *v)
2848 {
2849         return scst_proc_log_entry_read(seq, trace_flag, NULL);
2850 }
2851
2852 static ssize_t srpt_proc_trace_level_write(struct file *file,
2853         const char __user *buf, size_t length, loff_t *off)
2854 {
2855         return scst_proc_log_entry_write(file, buf, length, &trace_flag,
2856                 DEFAULT_SRPT_TRACE_FLAGS, NULL);
2857 }
2858
2859 static struct scst_proc_data srpt_log_proc_data = {
2860         SCST_DEF_RW_SEQ_OP(srpt_proc_trace_level_write)
2861         .show = srpt_trace_level_show,
2862 };
2863 #endif
2864
2865 #endif /* CONFIG_SCST_PROC */
2866
2867 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2868 static ssize_t show_login_info(struct class_device *class_dev, char *buf)
2869 #else
2870 static ssize_t show_login_info(struct device *dev,
2871                                struct device_attribute *attr, char *buf)
2872 #endif
2873 {
2874         struct srpt_device *sdev =
2875 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2876                 container_of(class_dev, struct srpt_device, class_dev);
2877 #else
2878                 container_of(dev, struct srpt_device, dev);
2879 #endif
2880         struct srpt_port *sport;
2881         int i;
2882         int len = 0;
2883
2884         for (i = 0; i < sdev->device->phys_port_cnt; i++) {
2885                 sport = &sdev->port[i];
2886
2887                 len += sprintf(buf + len,
2888                                "tid_ext=%016llx,ioc_guid=%016llx,pkey=ffff,"
2889                                "dgid=%04x%04x%04x%04x%04x%04x%04x%04x,"
2890                                "service_id=%016llx\n",
2891                                (unsigned long long) srpt_service_guid,
2892                                (unsigned long long) srpt_service_guid,
2893                                be16_to_cpu(((__be16 *) sport->gid.raw)[0]),
2894                                be16_to_cpu(((__be16 *) sport->gid.raw)[1]),
2895                                be16_to_cpu(((__be16 *) sport->gid.raw)[2]),
2896                                be16_to_cpu(((__be16 *) sport->gid.raw)[3]),
2897                                be16_to_cpu(((__be16 *) sport->gid.raw)[4]),
2898                                be16_to_cpu(((__be16 *) sport->gid.raw)[5]),
2899                                be16_to_cpu(((__be16 *) sport->gid.raw)[6]),
2900                                be16_to_cpu(((__be16 *) sport->gid.raw)[7]),
2901                                (unsigned long long) srpt_service_guid);
2902         }
2903
2904         return len;
2905 }
2906
2907 static struct class_attribute srpt_class_attrs[] = {
2908         __ATTR_NULL,
2909 };
2910
2911 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2912 static struct class_device_attribute srpt_dev_attrs[] = {
2913 #else
2914 static struct device_attribute srpt_dev_attrs[] = {
2915 #endif
2916         __ATTR(login_info, S_IRUGO, show_login_info, NULL),
2917         __ATTR_NULL,
2918 };
2919
2920 static struct class srpt_class = {
2921         .name        = "infiniband_srpt",
2922 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2923         .release = srpt_release_class_dev,
2924 #else
2925         .dev_release = srpt_release_class_dev,
2926 #endif
2927         .class_attrs = srpt_class_attrs,
2928 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2929         .class_dev_attrs = srpt_dev_attrs,
2930 #else
2931         .dev_attrs   = srpt_dev_attrs,
2932 #endif
2933 };
2934
2935 /**
2936  * srpt_add_one() - Callback function that is called once by the InfiniBand
2937  * core for each registered InfiniBand device.
2938  */
2939 static void srpt_add_one(struct ib_device *device)
2940 {
2941         struct srpt_device *sdev;
2942         struct srpt_port *sport;
2943         struct ib_srq_init_attr srq_attr;
2944         int i;
2945
2946         TRACE_ENTRY();
2947
2948         TRACE_DBG("device = %p, device->dma_ops = %p", device, device->dma_ops);
2949
2950         sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
2951         if (!sdev)
2952                 return;
2953
2954         sdev->scst_tgt = scst_register(&srpt_template, NULL);
2955         if (!sdev->scst_tgt) {
2956                 PRINT_ERROR("SCST registration failed for %s.",
2957                             sdev->device->name);
2958                 goto free_dev;
2959         }
2960
2961         scst_tgt_set_tgt_priv(sdev->scst_tgt, sdev);
2962
2963         sdev->device = device;
2964
2965 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2966         sdev->class_dev.class = &srpt_class;
2967         sdev->class_dev.dev = device->dma_device;
2968         snprintf(sdev->class_dev.class_id, BUS_ID_SIZE,
2969                  "srpt-%s", device->name);
2970 #else
2971         sdev->dev.class = &srpt_class;
2972         sdev->dev.parent = device->dma_device;
2973 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)
2974         snprintf(sdev->dev.bus_id, BUS_ID_SIZE, "srpt-%s", device->name);
2975 #else
2976         dev_set_name(&sdev->dev, "srpt-%s", device->name);
2977 #endif
2978 #endif
2979
2980 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
2981         if (class_device_register(&sdev->class_dev))
2982                 goto unregister_tgt;
2983 #else
2984         if (device_register(&sdev->dev))
2985                 goto unregister_tgt;
2986 #endif
2987
2988         if (ib_query_device(device, &sdev->dev_attr))
2989                 goto err_dev;
2990
2991         sdev->pd = ib_alloc_pd(device);
2992         if (IS_ERR(sdev->pd))
2993                 goto err_dev;
2994
2995         sdev->mr = ib_get_dma_mr(sdev->pd, IB_ACCESS_LOCAL_WRITE);
2996         if (IS_ERR(sdev->mr))
2997                 goto err_pd;
2998
2999         srq_attr.event_handler = srpt_srq_event;
3000         srq_attr.srq_context = (void *)sdev;
3001         srq_attr.attr.max_wr = min(SRPT_SRQ_SIZE, sdev->dev_attr.max_srq_wr);
3002         srq_attr.attr.max_sge = 1;
3003         srq_attr.attr.srq_limit = 0;
3004
3005         sdev->srq = ib_create_srq(sdev->pd, &srq_attr);
3006         if (IS_ERR(sdev->srq))
3007                 goto err_mr;
3008
3009         TRACE_DBG("%s: create SRQ #wr= %d max_allow=%d dev= %s",
3010                __func__, srq_attr.attr.max_wr,
3011               sdev->dev_attr.max_srq_wr, device->name);
3012
3013         if (!srpt_service_guid)
3014                 srpt_service_guid = be64_to_cpu(device->node_guid);
3015
3016         sdev->cm_id = ib_create_cm_id(device, srpt_cm_handler, sdev);
3017         if (IS_ERR(sdev->cm_id))
3018                 goto err_srq;
3019
3020         /* print out target login information */
3021         TRACE_DBG("Target login info: id_ext=%016llx,"
3022                   "ioc_guid=%016llx,pkey=ffff,service_id=%016llx",
3023                   (unsigned long long) srpt_service_guid,
3024                   (unsigned long long) srpt_service_guid,
3025                   (unsigned long long) srpt_service_guid);
3026
3027         /*
3028          * We do not have a consistent service_id (ie. also id_ext of target_id)
3029          * to identify this target. We currently use the guid of the first HCA
3030          * in the system as service_id; therefore, the target_id will change
3031          * if this HCA is gone bad and replaced by different HCA
3032          */
3033         if (ib_cm_listen(sdev->cm_id, cpu_to_be64(srpt_service_guid), 0, NULL))
3034                 goto err_cm;
3035
3036         INIT_IB_EVENT_HANDLER(&sdev->event_handler, sdev->device,
3037                               srpt_event_handler);
3038         if (ib_register_event_handler(&sdev->event_handler))
3039                 goto err_cm;
3040
3041         if (srpt_alloc_ioctx_ring(sdev, sdev->ioctx_ring,
3042                                   ARRAY_SIZE(sdev->ioctx_ring), 0))
3043                 goto err_event;
3044
3045         INIT_LIST_HEAD(&sdev->rch_list);
3046         spin_lock_init(&sdev->spinlock);
3047
3048         for (i = 0; i < SRPT_SRQ_SIZE; ++i)
3049                 srpt_post_recv(sdev, sdev->ioctx_ring[i]);
3050
3051         ib_set_client_data(device, &srpt_client, sdev);
3052
3053         WARN_ON(sdev->device->phys_port_cnt
3054                 > sizeof(sdev->port)/sizeof(sdev->port[0]));
3055
3056         for (i = 1; i <= sdev->device->phys_port_cnt; i++) {
3057                 sport = &sdev->port[i - 1];
3058                 sport->sdev = sdev;
3059                 sport->port = i;
3060 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20) && ! defined(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19)
3061                 /*
3062                  * A vanilla 2.6.19 or older kernel without backported OFED
3063                  * kernel headers.
3064                  */
3065                 INIT_WORK(&sport->work, srpt_refresh_port_work, sport);
3066 #else
3067                 INIT_WORK(&sport->work, srpt_refresh_port_work);
3068 #endif
3069                 if (srpt_refresh_port(sport)) {
3070                         PRINT_ERROR("MAD registration failed for %s-%d.",
3071                                     sdev->device->name, i);
3072                         goto err_ring;
3073                 }
3074         }
3075
3076         atomic_inc(&srpt_device_count);
3077
3078         TRACE_EXIT();
3079
3080         return;
3081
3082 err_ring:
3083         ib_set_client_data(device, &srpt_client, NULL);
3084         srpt_free_ioctx_ring(sdev, sdev->ioctx_ring,
3085                              ARRAY_SIZE(sdev->ioctx_ring));
3086 err_event:
3087         ib_unregister_event_handler(&sdev->event_handler);
3088 err_cm:
3089         ib_destroy_cm_id(sdev->cm_id);
3090 err_srq:
3091         ib_destroy_srq(sdev->srq);
3092 err_mr:
3093         ib_dereg_mr(sdev->mr);
3094 err_pd:
3095         ib_dealloc_pd(sdev->pd);
3096 err_dev:
3097 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
3098         class_device_unregister(&sdev->class_dev);
3099 #else
3100         device_unregister(&sdev->dev);
3101 #endif
3102 unregister_tgt:
3103         scst_unregister(sdev->scst_tgt);
3104 free_dev:
3105         kfree(sdev);
3106
3107         TRACE_EXIT();
3108 }
3109
3110 /*
3111  * Callback function called by the InfiniBand core when either an InfiniBand
3112  * device has been removed or during the ib_unregister_client() call for each
3113  * registered InfiniBand device.
3114  */
3115 static void srpt_remove_one(struct ib_device *device)
3116 {
3117         int i;
3118         struct srpt_device *sdev;
3119
3120         TRACE_ENTRY();
3121
3122         sdev = ib_get_client_data(device, &srpt_client);
3123 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
3124         WARN_ON(!sdev);
3125         if (!sdev)
3126                 return;
3127 #else
3128         if (WARN_ON(!sdev))
3129                 return;
3130 #endif
3131
3132         srpt_unregister_mad_agent(sdev);
3133
3134         ib_unregister_event_handler(&sdev->event_handler);
3135
3136         /* Cancel any work queued by the just unregistered IB event handler. */
3137         for (i = 0; i < sdev->device->phys_port_cnt; i++)
3138 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
3139                 cancel_work_sync(&sdev->port[i].work);
3140 #else
3141                 /*
3142                  * cancel_work_sync() was introduced in kernel 2.6.22. Older
3143                  * kernels do not have a facility to cancel scheduled work, so
3144                  * wait until the scheduled work finished.
3145                  */
3146                 flush_workqueue(&sdev->port[i].work);
3147 #endif
3148
3149         ib_destroy_cm_id(sdev->cm_id);
3150         ib_destroy_srq(sdev->srq);
3151         ib_dereg_mr(sdev->mr);
3152         ib_dealloc_pd(sdev->pd);
3153
3154 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
3155         class_device_unregister(&sdev->class_dev);
3156 #else
3157         device_unregister(&sdev->dev);
3158 #endif
3159
3160         /*
3161          * Unregistering an SCST target must happen after destroying sdev->cm_id
3162          * such that no new SRP_LOGIN_REQ information units can arrive while
3163          * destroying the SCST target.
3164          */
3165         scst_unregister(sdev->scst_tgt);
3166         sdev->scst_tgt = NULL;
3167
3168         srpt_free_ioctx_ring(sdev, sdev->ioctx_ring,
3169                              ARRAY_SIZE(sdev->ioctx_ring));
3170         kfree(sdev);
3171
3172         TRACE_EXIT();
3173 }
3174
3175 #ifdef CONFIG_SCST_PROC
3176
3177 /**
3178  * Create procfs entries for srpt. Currently the only procfs entry created
3179  * by this function is the "trace_level" entry.
3180  */
3181 static int srpt_register_procfs_entry(struct scst_tgt_template *tgt)
3182 {
3183         int res = 0;
3184 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
3185         struct proc_dir_entry *p, *root;
3186
3187         root = scst_proc_get_tgt_root(tgt);
3188         WARN_ON(!root);
3189         if (root) {
3190                 /*
3191                  * Fill in the scst_proc_data::data pointer, which is used in
3192                  * a printk(KERN_INFO ...) statement in
3193                  * scst_proc_log_entry_write() in scst_proc.c.
3194                  */
3195                 srpt_log_proc_data.data = (char *)tgt->name;
3196                 p = scst_create_proc_entry(root, SRPT_PROC_TRACE_LEVEL_NAME,
3197                                            &srpt_log_proc_data);
3198                 if (!p)
3199                         res = -ENOMEM;
3200         } else
3201                 res = -ENOMEM;
3202
3203 #endif
3204         return res;
3205 }
3206
3207 static void srpt_unregister_procfs_entry(struct scst_tgt_template *tgt)
3208 {
3209 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
3210         struct proc_dir_entry *root;
3211
3212         root = scst_proc_get_tgt_root(tgt);
3213         WARN_ON(!root);
3214         if (root)
3215                 remove_proc_entry(SRPT_PROC_TRACE_LEVEL_NAME, root);
3216 #endif
3217 }
3218
3219 #endif /*CONFIG_SCST_PROC*/
3220
3221 /*
3222  * Module initialization.
3223  *
3224  * Note: since ib_register_client() registers callback functions, and since at
3225  * least one of these callback functions (srpt_add_one()) calls SCST functions,
3226  * the SCST target template must be registered before ib_register_client() is
3227  * called.
3228  */
3229 static int __init srpt_init_module(void)
3230 {
3231         int ret;
3232
3233         ret = -EINVAL;
3234         if (srp_max_message_size < MIN_MAX_MESSAGE_SIZE) {
3235                 PRINT_ERROR("invalid value %d for kernel module parameter"
3236                             " srp_max_message_size -- must be at least %d.",
3237                             srp_max_message_size,
3238                             MIN_MAX_MESSAGE_SIZE);
3239                 goto out;
3240         }
3241
3242         ret = class_register(&srpt_class);
3243         if (ret) {
3244                 PRINT_ERROR("%s", "couldn't register class ib_srpt");
3245                 goto out;
3246         }
3247
3248         srpt_template.xmit_response_atomic = !thread;
3249         srpt_template.rdy_to_xfer_atomic = !thread;
3250         ret = scst_register_target_template(&srpt_template);
3251         if (ret < 0) {
3252                 PRINT_ERROR("%s", "couldn't register with scst");
3253                 ret = -ENODEV;
3254                 goto out_unregister_class;
3255         }
3256
3257 #ifdef CONFIG_SCST_PROC
3258         ret = srpt_register_procfs_entry(&srpt_template);
3259         if (ret) {
3260                 PRINT_ERROR("%s", "couldn't register procfs entry");
3261                 goto out_unregister_target;
3262         }
3263 #endif /*CONFIG_SCST_PROC*/
3264
3265         ret = ib_register_client(&srpt_client);
3266         if (ret) {
3267                 PRINT_ERROR("%s", "couldn't register IB client");
3268                 goto out_unregister_target;
3269         }
3270
3271         return 0;
3272
3273 out_unregister_target:
3274 #ifdef CONFIG_SCST_PROC
3275         /*
3276          * Note: the procfs entry is unregistered in srpt_release(), which is
3277          * called by scst_unregister_target_template().
3278          */
3279 #endif /*CONFIG_SCST_PROC*/
3280         scst_unregister_target_template(&srpt_template);
3281 out_unregister_class:
3282         class_unregister(&srpt_class);
3283 out:
3284         return ret;
3285 }
3286
3287 static void __exit srpt_cleanup_module(void)
3288 {
3289         TRACE_ENTRY();
3290
3291         ib_unregister_client(&srpt_client);
3292         scst_unregister_target_template(&srpt_template);
3293         class_unregister(&srpt_class);
3294
3295         TRACE_EXIT();
3296 }
3297
3298 module_init(srpt_init_module);
3299 module_exit(srpt_cleanup_module);