1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * SCSI Target Port I/F for Solaris SCSI RDMA Protocol Target (SRP)
28 * port provider module for the COMSTAR framework.
29 */
30
31 #include <sys/cpuvar.h>
32 #include <sys/types.h>
33 #include <sys/conf.h>
34 #include <sys/stat.h>
35 #include <sys/file.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 #include <sys/modctl.h>
39 #include <sys/sysmacros.h>
40 #include <sys/sdt.h>
41 #include <sys/taskq.h>
42 #include <sys/atomic.h>
43
44 #include <sys/stmf.h>
45 #include <sys/stmf_ioctl.h>
46 #include <sys/portif.h>
47
48 #include <sys/scsi/generic/persist.h>
49 #include <sys/ib/mgt/ibdma/ibdma.h>
50
51 #include "srp.h"
52 #include "srpt_impl.h"
53 #include "srpt_cm.h"
54 #include "srpt_ioc.h"
55 #include "srpt_ch.h"
56 #include "srpt_stp.h"
57
58 extern srpt_ctxt_t *srpt_ctxt;
59 extern uint32_t srpt_iu_size;
60
61 /*
62 * STMF LPort Interface Prototypes
63 */
64 static stmf_status_t srpt_stp_xfer_data(struct scsi_task *task,
65 struct stmf_data_buf *dbuf, uint32_t ioflags);
66 stmf_status_t srpt_stp_send_status(struct scsi_task *task,
67 uint32_t ioflags);
68 static void srpt_stp_task_free(struct scsi_task *task);
69 static stmf_status_t srpt_stp_abort(struct stmf_local_port *lport,
70 int abort_cmd, void *arg, uint32_t flags);
71 static void srpt_stp_task_poll(struct scsi_task *task);
72 static void srpt_stp_ctl(struct stmf_local_port *lport,
73 int cmd, void *arg);
74 static stmf_status_t srpt_stp_info(uint32_t cmd,
75 struct stmf_local_port *lport, void *arg, uint8_t *buf,
76 uint32_t *bufsizep);
77 static void srpt_stp_event_handler(struct stmf_local_port *lport,
78 int eventid, void *arg, uint32_t flags);
79
80 static void srpt_format_login_rsp(srp_login_req_t *req,
81 srp_login_rsp_t *rsp, uint8_t flags);
82 static void srpt_format_login_rej(srp_login_req_t *req,
83 srp_login_rej_t *rej, uint32_t reason);
84
85 static scsi_devid_desc_t *srpt_stp_alloc_scsi_devid_desc(uint64_t guid);
86 static void srpt_stp_free_scsi_devid_desc(scsi_devid_desc_t *sdd);
87
88 extern uint16_t srpt_send_msg_depth;
89
90 /*
91 * srpt_stp_start_srp() - Start SRP service
92 *
93 * Enable the SRP service for the specified SCSI Target Port.
94 */
95 int
96 srpt_stp_start_srp(srpt_target_port_t *tgt)
97 {
98 ibt_status_t status;
99 ibdma_status_t dma_status;
100 int port;
101 srpt_ioc_t *ioc;
102
103 if (tgt == NULL) {
104 SRPT_DPRINTF_L1("stp_start_srp, NULL SCSI target port");
105 return (IBT_FAILURE);
106 }
107
108 if (tgt->tp_ioc == NULL) {
109 SRPT_DPRINTF_L1("stp_start_srp, SCSI target port NULL"
110 " IOC pointer");
111 return (IBT_FAILURE);
112 }
113 ioc = tgt->tp_ioc;
114
115 SRPT_DPRINTF_L2("stp_start_srp, register SRP service for"
116 " svc_id (%016llx)", (u_longlong_t)tgt->tp_ibt_svc_id);
117 status = ibt_register_service(srpt_ctxt->sc_ibt_hdl,
118 &tgt->tp_ibt_svc_desc, tgt->tp_ibt_svc_id, 1,
119 &tgt->tp_ibt_svc_hdl, NULL);
120 if (status != IBT_SUCCESS) {
121 tgt->tp_ibt_svc_hdl = NULL;
122 SRPT_DPRINTF_L1("stp_start_srp, SRP service creation err (%d)",
123 status);
124 return (status);
125 }
126
127 /*
128 * Bind the service associated with the SCSI target port to
129 * each active port of the I/O Controller.
130 */
131 for (port = 0; port < ioc->ioc_attr.hca_nports; port++) {
132 status = srpt_ioc_svc_bind(tgt, port+1);
133 if (status != IBT_SUCCESS &&
134 status != IBT_HCA_PORT_NOT_ACTIVE) {
135 SRPT_DPRINTF_L1("start_srp, Unable to bind"
136 " service (%d)", status);
137 goto srp_start_err;
138 }
139 }
140
141 /* don't online if we have no active ports */
142 if (tgt->tp_num_active_ports == 0) {
143 SRPT_DPRINTF_L2("start_srp, no ports active for svc_id %016llx",
144 (u_longlong_t)tgt->tp_ibt_svc_id);
145 status = IBT_HCA_PORT_NOT_ACTIVE;
146 goto srp_start_err;
147 }
148
149 tgt->tp_srp_enabled = 1;
150
151 /*
152 * Calculate the new I/O Controller profile and either update the
153 * profile if previously registered or register it with the IB
154 * Device Management Agent.
155 */
156 SRPT_DPRINTF_L3("start_srp, update I/O Controller profile (%016llx)",
157 (u_longlong_t)ioc->ioc_guid);
158
159 srpt_ioc_init_profile(ioc);
160 if (ioc->ioc_ibdma_hdl == NULL) {
161 ioc->ioc_ibdma_hdl =
162 srpt_ctxt->sc_ibdma_ops.ibdma_register(ioc->ioc_guid,
163 &ioc->ioc_profile, &ioc->ioc_svc);
164 if (ioc->ioc_ibdma_hdl == NULL) {
165 SRPT_DPRINTF_L1("start_srp, Unable to register"
166 " I/O Profile for svc_id %016llx",
167 (u_longlong_t)tgt->tp_ibt_svc_id);
168 status = IBT_FAILURE;
169 goto srp_start_err;
170 }
171 } else {
172 dma_status =
173 srpt_ctxt->sc_ibdma_ops.ibdma_update(ioc->ioc_ibdma_hdl,
174 &ioc->ioc_profile, &ioc->ioc_svc);
175 if (dma_status != IBDMA_SUCCESS) {
176 SRPT_DPRINTF_L1("start_srp, Unable to update I/O"
177 " Profile for svc_id %016llxi (%d)",
178 (u_longlong_t)tgt->tp_ibt_svc_id, dma_status);
179 status = IBT_FAILURE;
180 goto srp_start_err;
181 }
182 }
183
184 return (IBT_SUCCESS);
185
186 srp_start_err:
187 tgt->tp_srp_enabled = 0;
188 srpt_ioc_svc_unbind_all(tgt);
189 tgt->tp_num_active_ports = 0;
190 if (tgt->tp_ibt_svc_hdl != NULL) {
191 (void) ibt_deregister_service(srpt_ctxt->sc_ibt_hdl,
192 tgt->tp_ibt_svc_hdl);
193 tgt->tp_ibt_svc_hdl = NULL;
194 }
195 return (status);
196 }
197
198 /*
199 * srpt_stp_stop_srp() - Stop SRP service.
200 *
201 * Disable the SRP service on the specified SCSI Target Port.
202 */
203 void
204 srpt_stp_stop_srp(srpt_target_port_t *tgt)
205 {
206 ibt_status_t status;
207 ibdma_status_t dma_status;
208 srpt_ioc_t *ioc;
209 srpt_channel_t *ch;
210
211 if (tgt == NULL) {
212 SRPT_DPRINTF_L2("stp_stop_srp, NULL SCSI Target Port"
213 " specified");
214 return;
215 }
216
217 if (tgt->tp_ioc == NULL) {
218 SRPT_DPRINTF_L2("stp_stop_srp, bad Target, IOC NULL");
219 return;
220 }
221 ioc = tgt->tp_ioc;
222
223 /*
224 * Update the I/O Controller profile to remove the SRP service
225 * for this SCSI target port.
226 */
227 tgt->tp_srp_enabled = 0;
228
229 if (ioc->ioc_ibdma_hdl != NULL) {
230 SRPT_DPRINTF_L3("stp_stop_srp, update I/O Controller"
231 " profile (%016llx)", (u_longlong_t)ioc->ioc_guid);
232 srpt_ioc_init_profile(ioc);
233
234 if (ioc->ioc_profile.ioc_service_entries == 0) {
235 SRPT_DPRINTF_L3("stp_stop_srp, no services active"
236 " unregister IOC profile");
237 srpt_ctxt->sc_ibdma_ops.ibdma_unregister(
238 ioc->ioc_ibdma_hdl);
239 ioc->ioc_ibdma_hdl = NULL;
240 } else {
241 dma_status = srpt_ctxt->sc_ibdma_ops.ibdma_update(
242 ioc->ioc_ibdma_hdl, &ioc->ioc_profile,
243 &ioc->ioc_svc);
244 if (dma_status != IBDMA_SUCCESS) {
245 SRPT_DPRINTF_L1("stp_stop_srp, Unable to"
246 " update I/O Profile (%d)", dma_status);
247 return;
248 }
249 }
250 }
251
252 /*
253 * Unbind the SRP service associated with the SCSI target port
254 * from all of the I/O Controller physical ports.
255 */
256 SRPT_DPRINTF_L2("stp_stop_srp, unbind and de-register service"
257 "(%016llx)", (u_longlong_t)tgt->tp_ibt_svc_id);
258 if (tgt->tp_ibt_svc_hdl != NULL) {
259 srpt_ioc_svc_unbind_all(tgt);
260 }
261
262 if (tgt->tp_ibt_svc_hdl != NULL) {
263 status = ibt_deregister_service(srpt_ctxt->sc_ibt_hdl,
264 tgt->tp_ibt_svc_hdl);
265 if (status != IBT_SUCCESS) {
266 SRPT_DPRINTF_L1("stp_stop_srp, de-register service"
267 " error(%d)", status);
268 }
269 tgt->tp_ibt_svc_hdl = NULL;
270 }
271
272 /*
273 * SRP service is now off-line for this SCSI Target Port.
274 * We force a disconnect (i.e. SRP Target Logout) for any
275 * active SRP logins.
276 */
277 mutex_enter(&tgt->tp_ch_list_lock);
278 ch = list_head(&tgt->tp_ch_list);
279 while (ch != NULL) {
280 SRPT_DPRINTF_L3("stp_stop_srp, disconnect ch(%p)",
281 (void *)ch);
282 srpt_ch_disconnect(ch);
283 ch = list_next(&tgt->tp_ch_list, ch);
284 }
285 mutex_exit(&tgt->tp_ch_list_lock);
286
287 /*
288 * wait for all sessions to terminate before returning
289 */
290 mutex_enter(&tgt->tp_sess_list_lock);
291 while (!list_is_empty(&tgt->tp_sess_list)) {
292 cv_wait(&tgt->tp_sess_complete, &tgt->tp_sess_list_lock);
293 }
294 mutex_exit(&tgt->tp_sess_list_lock);
295 }
296
297 /*
298 * srpt_stp_alloc_port() - Allocate SCSI Target Port
299 */
300 srpt_target_port_t *
301 srpt_stp_alloc_port(srpt_ioc_t *ioc, ib_guid_t guid)
302 {
303 stmf_status_t status;
304 srpt_target_port_t *tgt;
305 stmf_local_port_t *lport;
306 uint64_t temp;
307
308 if (ioc == NULL) {
309 SRPT_DPRINTF_L1("stp_alloc_port, NULL I/O Controller");
310 return (NULL);
311 }
312
313 SRPT_DPRINTF_L3("stp_alloc_port, allocate STMF local port");
314 lport = stmf_alloc(STMF_STRUCT_STMF_LOCAL_PORT, sizeof (*tgt), 0);
315 if (lport == NULL) {
316 SRPT_DPRINTF_L1("tgt_alloc_port, stmf_alloc failed");
317 return (NULL);
318 }
319
320 tgt = lport->lport_port_private;
321 ASSERT(tgt != NULL);
322
323 mutex_init(&tgt->tp_lock, NULL, MUTEX_DRIVER, NULL);
324
325 mutex_init(&tgt->tp_ch_list_lock, NULL, MUTEX_DRIVER, NULL);
326 cv_init(&tgt->tp_offline_complete, NULL, CV_DRIVER, NULL);
327 list_create(&tgt->tp_ch_list, sizeof (srpt_channel_t),
328 offsetof(srpt_channel_t, ch_stp_node));
329
330 mutex_init(&tgt->tp_sess_list_lock, NULL, MUTEX_DRIVER, NULL);
331 cv_init(&tgt->tp_sess_complete, NULL, CV_DRIVER, NULL);
332 list_create(&tgt->tp_sess_list, sizeof (srpt_session_t),
333 offsetof(srpt_session_t, ss_node));
334
335 tgt->tp_state = SRPT_TGT_STATE_OFFLINE;
336 tgt->tp_drv_disabled = 0;
337 tgt->tp_srp_enabled = 0;
338 tgt->tp_lport = lport;
339 tgt->tp_ioc = ioc;
340 tgt->tp_ibt_svc_id = guid;
341 tgt->tp_ibt_svc_desc.sd_handler = srpt_cm_hdlr;
342 tgt->tp_ibt_svc_desc.sd_flags = IBT_SRV_NO_FLAGS;
343 temp = h2b64(tgt->tp_ibt_svc_id);
344 bcopy(&temp, &tgt->tp_srp_port_id[0], 8);
345 temp = h2b64(tgt->tp_ioc->ioc_guid);
346 bcopy(&temp, &tgt->tp_srp_port_id[8], 8);
347
348 tgt->tp_nports = ioc->ioc_attr.hca_nports;
349 tgt->tp_hw_port =
350 kmem_zalloc(sizeof (srpt_hw_port_t) * tgt->tp_nports, KM_SLEEP);
351 tgt->tp_num_active_ports = 0;
352 tgt->tp_requested_state = SRPT_TGT_STATE_OFFLINE;
353
354 tgt->tp_scsi_devid = srpt_stp_alloc_scsi_devid_desc(tgt->tp_ibt_svc_id);
355
356 lport->lport_id = tgt->tp_scsi_devid;
357 lport->lport_pp = srpt_ctxt->sc_pp;
358 lport->lport_ds = ioc->ioc_stmf_ds;
359 lport->lport_xfer_data = &srpt_stp_xfer_data;
360 lport->lport_send_status = &srpt_stp_send_status;
361 lport->lport_task_free = &srpt_stp_task_free;
362 lport->lport_abort = &srpt_stp_abort;
363 lport->lport_abort_timeout = 300; /* 5 minutes */
364 lport->lport_task_poll = &srpt_stp_task_poll;
365 lport->lport_ctl = &srpt_stp_ctl;
366 lport->lport_info = &srpt_stp_info;
367 lport->lport_event_handler = &srpt_stp_event_handler;
368
369 /* set up as alua participating port */
370 stmf_set_port_alua(lport);
371
372 SRPT_DPRINTF_L3("stp_alloc_port, register STMF LPORT");
373
374 retry_registration:
375 status = stmf_register_local_port(lport);
376 if (status == STMF_SUCCESS) {
377 SRPT_DPRINTF_L3("stp_alloc_port, LPORT successfully"
378 " registered");
379 return (tgt);
380 }
381
382 if (status == STMF_BUSY) {
383 /*
384 * This is only done on an administrative thread of
385 * execution so it is ok to take a while.
386 */
387 SRPT_DPRINTF_L3("stp_alloc_port, delaying");
388 delay(2 * drv_usectohz(1000000));
389 goto retry_registration;
390 }
391 SRPT_DPRINTF_L1("stp_alloc_port, STMF register local port err(0x%llx)",
392 (u_longlong_t)status);
393
394 SRPT_DPRINTF_L3("stp_alloc_port, free STMF local port");
395 cv_destroy(&tgt->tp_offline_complete);
396 mutex_destroy(&tgt->tp_ch_list_lock);
397 mutex_destroy(&tgt->tp_lock);
398 if (tgt->tp_hw_port) {
399 kmem_free(tgt->tp_hw_port,
400 sizeof (srpt_hw_port_t) * tgt->tp_nports);
401 }
402 if (tgt->tp_scsi_devid) {
403 srpt_stp_free_scsi_devid_desc(tgt->tp_scsi_devid);
404 }
405
406 stmf_free(lport);
407
408 return (NULL);
409 }
410
411 /*
412 * srpt_stp_free_port() - Free SCSI Target Port
413 */
414 stmf_status_t
415 srpt_stp_free_port(srpt_target_port_t *tgt)
416 {
417 ASSERT(tgt != NULL);
418 ASSERT(list_is_empty(&tgt->tp_sess_list));
419 ASSERT(list_is_empty(&tgt->tp_ch_list));
420
421 list_destroy(&tgt->tp_ch_list);
422 list_destroy(&tgt->tp_sess_list);
423
424 cv_destroy(&tgt->tp_sess_complete);
425 cv_destroy(&tgt->tp_offline_complete);
426
427 mutex_destroy(&tgt->tp_sess_list_lock);
428 mutex_destroy(&tgt->tp_ch_list_lock);
429 mutex_destroy(&tgt->tp_lock);
430
431
432 SRPT_DPRINTF_L3("stp_free_port, free STMF local port");
433 if (tgt->tp_hw_port) {
434 kmem_free(tgt->tp_hw_port,
435 sizeof (srpt_hw_port_t) * tgt->tp_nports);
436 }
437
438 if (tgt->tp_scsi_devid) {
439 srpt_stp_free_scsi_devid_desc(tgt->tp_scsi_devid);
440 }
441
442 stmf_free(tgt->tp_lport);
443
444 return (STMF_SUCCESS);
445 }
446
447 /*
448 * srpt_stp_destroy_port()
449 */
450 stmf_status_t
451 srpt_stp_destroy_port(srpt_target_port_t *tgt)
452 {
453 stmf_status_t status;
454 stmf_change_status_t cstatus;
455 uint64_t guid;
456
457 ASSERT(tgt != NULL);
458 ASSERT(tgt->tp_lport != NULL);
459
460 SRPT_DPRINTF_L3("stp_destroy_port, de-register STMF LPORT");
461
462 mutex_enter(&tgt->tp_lock);
463 if (tgt->tp_drv_disabled != 0) {
464 /* already being destroyed, get out now - should not happen */
465 mutex_exit(&tgt->tp_lock);
466 return (STMF_ALREADY);
467 }
468
469 tgt->tp_drv_disabled = 1;
470 guid = tgt->tp_ioc->ioc_guid;
471 mutex_exit(&tgt->tp_lock);
472
473 SRPT_DPRINTF_L2("stp_destroy_port: unbind and de-register"
474 " services for GUID(%016llx)", (u_longlong_t)guid);
475
476 cstatus.st_completion_status = STMF_SUCCESS;
477 cstatus.st_additional_info = NULL;
478
479 status = stmf_ctl(STMF_CMD_LPORT_OFFLINE, tgt->tp_lport, &cstatus);
480
481 /*
482 * Wait for asynchronous target off-line operation
483 * to complete and then deregister the target
484 * port.
485 */
486 mutex_enter(&tgt->tp_lock);
487 while (tgt->tp_state != SRPT_TGT_STATE_OFFLINE) {
488 cv_wait(&tgt->tp_offline_complete, &tgt->tp_lock);
489 }
490 mutex_exit(&tgt->tp_lock);
491
492 SRPT_DPRINTF_L3("stp_destroy_port: IOC (0x%016llx) Target"
493 " SRP off-line complete", (u_longlong_t)guid);
494
495 /* loop waiting for all I/O to drain */
496 for (;;) {
497 status = stmf_deregister_local_port(tgt->tp_lport);
498 if (status == STMF_BUSY) {
499 delay(drv_usectohz(1000000));
500 } else {
501 break;
502 }
503 }
504
505 if (status == STMF_SUCCESS) {
506 SRPT_DPRINTF_L3("stp_destroy_port, LPORT de-register"
507 " complete");
508 } else {
509 /*
510 * Something other than a BUSY error, this should not happen.
511 */
512 SRPT_DPRINTF_L1(
513 "stp_destroy_port, de-register STMF error(0x%llx)",
514 (u_longlong_t)status);
515 }
516
517 return (status);
518 }
519
520 /*
521 * srpt_stp_xfer_data()
522 */
523 /* ARGSUSED */
524 static stmf_status_t
525 srpt_stp_xfer_data(struct scsi_task *task, struct stmf_data_buf *dbuf,
526 uint32_t ioflags)
527 {
528 srpt_iu_t *iu;
529 srpt_channel_t *ch;
530 srpt_ds_dbuf_t *db;
531 ibt_send_wr_t wr;
532 ibt_wr_ds_t ds;
533 ibt_status_t status;
534 uint32_t xfer_len;
535 uint32_t xferred_len;
536 uint32_t rdma_len;
537 uint32_t base_offset;
538 uint32_t desc_offset;
539 srp_direct_desc_t *desc;
540
541 SRPT_DPRINTF_L3("stp_xfer_data, invoked task (%p), dbuf (%p)",
542 (void *)task, (void *)dbuf);
543 iu = task->task_port_private;
544 ASSERT(iu != NULL);
545 ASSERT(iu->iu_ch != NULL);
546 /*
547 * We should use iu->iu_ch->ch_swqe_posted to throttle
548 * send wqe posting. This is very unlikely because we limit
549 * the maximum number of initiator descriptors per IU (impact
550 * of fragmentation of intiator buffer space) but it could occur
551 * if the back-end (STMF) were to use too many small buffers. In
552 * that case we would want to return STMF_BUSY.
553 */
554
555 SRPT_DPRINTF_L4("stp_xfer_data, dbuf->db_flags (0x%x)",
556 dbuf->db_flags);
557 SRPT_DPRINTF_L4("stp_xfer_data, dbuf->db_data_size (%d)",
558 dbuf->db_data_size);
559 SRPT_DPRINTF_L4("stp_xfer_data, dbuf->db_relative_offset (%d)",
560 dbuf->db_relative_offset);
561
562 ASSERT((dbuf->db_flags & (DB_DIRECTION_TO_RPORT |
563 DB_DIRECTION_FROM_RPORT)) != (DB_DIRECTION_TO_RPORT |
564 DB_DIRECTION_FROM_RPORT));
565
566 db = dbuf->db_port_private;
567
568 /*
569 * Check to see if request will overflow the remote buffer; if so
570 * return a bad status and let STMF abort the task.
571 */
572 if ((dbuf->db_relative_offset + dbuf->db_data_size) >
573 iu->iu_tot_xfer_len) {
574 SRPT_DPRINTF_L2("stp_xfer_data, overflow of remote buffer");
575 return (STMF_FAILURE);
576 }
577
578 db->db_iu = iu;
579 wr.wr_trans = IBT_RC_SRV;
580 wr.wr_opcode = (dbuf->db_flags & DB_DIRECTION_TO_RPORT) ?
581 IBT_WRC_RDMAW : IBT_WRC_RDMAR;
582 wr.wr_nds = 1;
583 wr.wr_sgl = &ds;
584
585 /*
586 * We know that the data transfer is within the bounds described
587 * by our list of remote buffer descriptors. Find the starting
588 * point based on the offset for the transfer, then perform the
589 * RDMA operations required of this transfer.
590 */
591 base_offset = 0;
592 desc = iu->iu_rdescs;
593
594 while ((base_offset + desc->dd_len) < dbuf->db_relative_offset) {
595 base_offset += desc->dd_len;
596 desc++;
597 }
598
599 xfer_len = dbuf->db_data_size;
600 xferred_len = 0;
601 desc_offset = dbuf->db_relative_offset - base_offset;
602
603 ch = iu->iu_ch;
604
605 /*
606 * If the channel is no longer connected then return an
607 * error and do not initiate I/O. STMF should abort the
608 * task.
609 */
610 rw_enter(&ch->ch_rwlock, RW_READER);
611
612 if (iu->iu_ch->ch_state == SRPT_CHANNEL_DISCONNECTING) {
613 rw_exit(&iu->iu_ch->ch_rwlock);
614 return (STMF_FAILURE);
615 }
616
617 while (xfer_len > 0) {
618 rdma_len = desc->dd_len - desc_offset;
619
620 /*
621 * We only generate completion entries on the last IB
622 * operation associated with any STMF buffer.
623 */
624 if (rdma_len >= xfer_len) {
625 rdma_len = xfer_len;
626 wr.wr_flags = IBT_WR_SEND_SIGNAL;
627 } else {
628 wr.wr_flags = IBT_WR_NO_FLAGS;
629 }
630
631 wr.wr.rc.rcwr.rdma.rdma_raddr = desc->dd_vaddr + desc_offset;
632 wr.wr.rc.rcwr.rdma.rdma_rkey = desc->dd_hdl;
633 ds.ds_va = db->db_sge.ds_va + xferred_len;
634 ds.ds_key = db->db_sge.ds_key;
635 ds.ds_len = rdma_len;
636
637 SRPT_DPRINTF_L4("stp_xfer_data, post RDMA operation");
638
639 /*
640 * If this task is being aborted or has been aborted,
641 * do not post additional I/O.
642 */
643 DTRACE_SRP_8(xfer__start, srpt_channel_t, ch,
644 ibt_wr_ds_t, &(db->db_sge), srpt_iu_t, iu,
645 ibt_send_wr_t, &wr, uint32_t, rdma_len,
646 uint32_t, xferred_len, uint32_t, desc_offset,
647 uint32_t, wr.wr_opcode == IBT_WRC_RDMAR ? 0 : 1);
648 mutex_enter(&iu->iu_lock);
649 if ((iu->iu_flags & (SRPT_IU_SRP_ABORTING |
650 SRPT_IU_STMF_ABORTING | SRPT_IU_ABORTED)) != 0) {
651 mutex_exit(&iu->iu_lock);
652 rw_exit(&iu->iu_ch->ch_rwlock);
653 return (STMF_SUCCESS);
654 }
655
656 /*
657 * If a non-error CQE will be requested, add a reference to
658 * the IU and initialize the work request appropriately.
659 */
660 if ((wr.wr_flags & IBT_WR_SEND_SIGNAL) != 0) {
661 wr.wr_id = srpt_ch_alloc_swqe_wrid(ch,
662 SRPT_SWQE_TYPE_DATA, (void *)dbuf);
663 if (wr.wr_id == 0) {
664 rw_exit(&iu->iu_ch->ch_rwlock);
665 mutex_exit(&iu->iu_lock);
666 return (STMF_BUSY);
667 }
668 atomic_inc_32(&iu->iu_sq_posted_cnt);
669 } else {
670 wr.wr_id = 0;
671 }
672
673 status = ibt_post_send(iu->iu_ch->ch_chan_hdl, &wr, 1, NULL);
674 mutex_exit(&iu->iu_lock);
675
676 if (status != IBT_SUCCESS) {
677 /*
678 * Could not post to IB transport, report to STMF and
679 * and let it initiate an abort of the task.
680 */
681 SRPT_DPRINTF_L2("stp_xfer_data, post RDMA"
682 " error (%d)", status);
683
684 if ((wr.wr_flags & IBT_WR_SEND_SIGNAL) != 0) {
685 srpt_ch_free_swqe_wrid(ch, wr.wr_id);
686 atomic_dec_32(&iu->iu_sq_posted_cnt);
687 }
688 rw_exit(&iu->iu_ch->ch_rwlock);
689 return (STMF_FAILURE);
690 }
691 xferred_len += rdma_len;
692 xfer_len -= rdma_len;
693 desc_offset = 0;
694 desc++;
695 }
696
697 rw_exit(&ch->ch_rwlock);
698 return (STMF_SUCCESS);
699 }
700
701 /*
702 * srpt_stp_send_mgmt_response() - Return SRP task managment response IU
703 */
704 ibt_status_t
705 srpt_stp_send_mgmt_response(srpt_iu_t *iu, uint8_t srp_rsp,
706 uint_t fence)
707 {
708 srp_rsp_t *rsp;
709 srp_rsp_data_t *data;
710 uint32_t rsp_length;
711 ibt_status_t status;
712 uint8_t *bufp;
713
714 ASSERT(mutex_owned(&iu->iu_lock));
715 rsp = iu->iu_buf;
716 bufp = (uint8_t *)iu->iu_buf + SRP_RSP_SIZE;
717 bzero(rsp, SRP_RSP_SIZE + sizeof (srp_rsp_data_t));
718 rsp->rsp_type = SRP_IU_RSP;
719
720 /*
721 * Report ULP credits we have added since last response sent
722 * over this channel.
723 */
724 rsp->rsp_req_limit_delta =
725 h2b32(atomic_swap_32(&iu->iu_ch->ch_req_lim_delta, 0));
726 rsp->rsp_tag = iu->iu_tag;
727
728 /* srp_rsp_t is padded out, so use explicit size here */
729 rsp_length = SRP_RSP_SIZE;
730 if (srp_rsp != SRP_TM_SUCCESS) {
731 rsp->rsp_flags |= SRP_RSP_VALID;
732 data = (srp_rsp_data_t *)bufp;
733 data->rd_rsp_status = srp_rsp;
734 rsp->rsp_data_len = h2b32(sizeof (srp_rsp_data_t));
735 rsp_length += sizeof (srp_rsp_data_t);
736 }
737
738 SRPT_DPRINTF_L4("stp_send_mgmt_response, sending on ch(%p),"
739 " iu(%p), mgmt status(%d)", (void *)iu->iu_ch,
740 (void *)iu, srp_rsp);
741
742 DTRACE_SRP_4(task__response, srpt_channel_t, iu->iu_ch,
743 srp_rsp_t, iu->iu_buf, scsi_task_t, iu->iu_stmf_task,
744 int8_t, srp_rsp);
745
746 status = srpt_ch_post_send(iu->iu_ch, iu, rsp_length, fence);
747 if (status != IBT_SUCCESS) {
748 SRPT_DPRINTF_L2("stp_send_mgmt_response, post "
749 "response err(%d)", status);
750 }
751 return (status);
752 }
753
754 /*
755 * srpt_stp_send_response() - Send SRP command response IU
756 */
757 ibt_status_t
758 srpt_stp_send_response(srpt_iu_t *iu, uint8_t scsi_status,
759 uint8_t flags, uint32_t resid, uint16_t sense_length,
760 uint8_t *sense_data, uint_t fence)
761 {
762 srp_rsp_t *rsp;
763 uint32_t rsp_length;
764 uint8_t *bufp;
765 ibt_status_t status;
766
767 ASSERT(mutex_owned(&iu->iu_lock));
768 rsp = iu->iu_buf;
769 bufp = (uint8_t *)iu->iu_buf + SRP_RSP_SIZE;
770 bzero(rsp, SRP_RSP_SIZE);
771 rsp->rsp_type = SRP_IU_RSP;
772
773 /*
774 * Report ULP credits we have added since last response sent
775 * over this channel.
776 */
777 rsp->rsp_req_limit_delta =
778 h2b32(atomic_swap_32(&iu->iu_ch->ch_req_lim_delta, 0));
779 rsp->rsp_tag = iu->iu_tag;
780 rsp->rsp_status = scsi_status;
781
782 rsp_length = SRP_RSP_SIZE;
783
784 if (resid != 0) {
785 rsp->rsp_flags |= flags;
786
787 if ((flags & SRP_RSP_DO_OVER) ||
788 (flags & SRP_RSP_DO_UNDER)) {
789 rsp->rsp_do_resid_cnt = h2b32(resid);
790 } else if ((flags & SRP_RSP_DI_OVER) ||
791 (flags & SRP_RSP_DI_UNDER)) {
792 rsp->rsp_di_resid_cnt = h2b32(resid);
793 }
794 }
795
796 if (sense_length != 0) {
797 rsp->rsp_flags |= SRP_RSP_SNS_VALID;
798 if (SRP_RSP_SIZE + sense_length >
799 iu->iu_ch->ch_ti_iu_len) {
800 sense_length = iu->iu_ch->ch_ti_iu_len -
801 SRP_RSP_SIZE;
802 }
803 bcopy(sense_data, bufp, sense_length);
804 rsp->rsp_sense_data_len = h2b32(sense_length);
805 rsp_length += sense_length;
806 }
807
808 SRPT_DPRINTF_L4("stp_send_reponse, sending on ch(%p),"
809 " iu(%p), length(%d)", (void *)iu->iu_ch,
810 (void *)iu, rsp_length);
811
812 DTRACE_SRP_4(task__response, srpt_channel_t, iu->iu_ch,
813 srp_rsp_t, iu->iu_buf, scsi_task_t, iu->iu_stmf_task,
814 uint8_t, scsi_status);
815
816 status = srpt_ch_post_send(iu->iu_ch, iu, rsp_length, fence);
817 if (status != IBT_SUCCESS) {
818 SRPT_DPRINTF_L2("stp_send_response, post response err(%d)",
819 status);
820 }
821 return (status);
822 }
823
824 /*
825 * srpt_stp_send_status()
826 */
827 /* ARGSUSED */
828 stmf_status_t
829 srpt_stp_send_status(struct scsi_task *task, uint32_t ioflags)
830 {
831 srpt_iu_t *iu;
832 ibt_status_t status;
833
834 ASSERT(task != NULL);
835 iu = task->task_port_private;
836
837 ASSERT(iu != NULL);
838
839 mutex_enter(&iu->iu_lock);
840
841 ASSERT(iu->iu_ch != NULL);
842
843 SRPT_DPRINTF_L3("stp_send_status, invoked task (%p)"
844 ", task_completion_status (%d)"
845 ", task_resid (%d)"
846 ", task_status_ctrl (%d)"
847 ", task_scsi_status (%d)"
848 ", task_sense_length (%d)"
849 ", task_sense_data (%p)",
850 (void *)task,
851 (int)task->task_completion_status,
852 task->task_resid,
853 task->task_status_ctrl,
854 task->task_scsi_status,
855 task->task_sense_length,
856 (void *)task->task_sense_data);
857
858 DTRACE_SRP_4(scsi__response, srpt_channel_t, iu->iu_ch,
859 srp_rsp_t, iu->iu_buf, scsi_task_t, task,
860 int8_t, task->task_scsi_status);
861
862 if ((iu->iu_flags & (SRPT_IU_STMF_ABORTING |
863 SRPT_IU_SRP_ABORTING | SRPT_IU_ABORTED)) != 0) {
864 mutex_exit(&iu->iu_lock);
865 return (STMF_FAILURE);
866 }
867
868 /*
869 * Indicate future aborts can not be initiated (although
870 * we will handle any that have been requested since the
871 * last I/O completed and before we are sending status).
872 */
873 iu->iu_flags |= SRPT_IU_RESP_SENT;
874
875 /*
876 * Send SRP command response or SRP task mgmt response.
877 */
878 if (task->task_mgmt_function == 0) {
879 uint8_t rsp_flags = 0;
880 uint32_t resbytes = 0;
881
882 if (task->task_status_ctrl == TASK_SCTRL_OVER) {
883 resbytes = task->task_resid;
884
885 if (task->task_flags & TF_READ_DATA) {
886 SRPT_DPRINTF_L3(
887 "stp_send_status, data out overrun");
888 rsp_flags |= SRP_RSP_DO_OVER;
889 } else if (task->task_flags & TF_WRITE_DATA) {
890 SRPT_DPRINTF_L3(
891 "stp_send_status, data in overrun");
892 rsp_flags |= SRP_RSP_DI_OVER;
893 }
894 } else if (task->task_status_ctrl == TASK_SCTRL_UNDER) {
895 resbytes = task->task_resid;
896
897 if (task->task_flags & TF_READ_DATA) {
898 SRPT_DPRINTF_L3(
899 "stp_send_status, data out underrun");
900 rsp_flags |= SRP_RSP_DO_UNDER;
901 } else if (task->task_flags & TF_WRITE_DATA) {
902 SRPT_DPRINTF_L3(
903 "stp_send_status, data in underrun");
904 rsp_flags |= SRP_RSP_DI_UNDER;
905 }
906 }
907
908 status = srpt_stp_send_response(iu,
909 task->task_scsi_status, rsp_flags, resbytes,
910 task->task_sense_length, task->task_sense_data, 0);
911 } else {
912 status = srpt_stp_send_mgmt_response(iu,
913 (task->task_scsi_status ?
914 SRP_TM_FAILED : SRP_TM_SUCCESS),
915 SRPT_FENCE_SEND);
916 }
917
918 /*
919 * If we have an error posting the response return bad status
920 * to STMF and let it initiate an abort for the task.
921 */
922 if (status != IBT_SUCCESS) {
923 SRPT_DPRINTF_L2("stp_send_status, post response err(%d)",
924 status);
925
926 /* clear the response sent flag since it never went out */
927 iu->iu_flags &= ~SRPT_IU_RESP_SENT;
928
929 mutex_exit(&iu->iu_lock);
930 return (STMF_FAILURE);
931 }
932 mutex_exit(&iu->iu_lock);
933 return (STMF_SUCCESS);
934 }
935
936 /*
937 * srpt_stp_task_free() - STMF call-back.
938 */
939 static void
940 srpt_stp_task_free(struct scsi_task *task)
941 {
942 srpt_iu_t *iu;
943 srpt_channel_t *ch;
944
945 SRPT_DPRINTF_L3("stp_task_free, invoked task (%p)",
946 (void *)task);
947
948 iu = task->task_port_private;
949 ASSERT(iu != NULL);
950
951 mutex_enter(&iu->iu_lock);
952 ch = iu->iu_ch;
953 mutex_exit(&iu->iu_lock);
954
955 ASSERT(ch != NULL);
956 ASSERT(ch->ch_session != NULL);
957
958 /*
959 * Do not hold IU lock while task is being removed from
960 * the session list - possible deadlock if cleaning up
961 * channel when this is called.
962 */
963 srpt_stp_remove_task(ch->ch_session, iu);
964
965 mutex_enter(&iu->iu_lock);
966 iu->iu_stmf_task = NULL;
967
968 srpt_ioc_repost_recv_iu(iu->iu_ioc, iu);
969
970 mutex_exit(&iu->iu_lock);
971
972 srpt_ch_release_ref(ch, 0);
973 }
974
975 /*
976 * srpt_stp_abort() - STMF call-back.
977 */
978 /* ARGSUSED */
979 static stmf_status_t
980 srpt_stp_abort(struct stmf_local_port *lport, int abort_cmd,
981 void *arg, uint32_t flags)
982 {
983 struct scsi_task *task;
984 srpt_iu_t *iu;
985 stmf_status_t status;
986
987 SRPT_DPRINTF_L3("stp_abort, invoked lport (%p), arg (%p)",
988 (void *)lport, (void *)arg);
989
990 task = (struct scsi_task *)arg;
991 ASSERT(task != NULL);
992
993 iu = (srpt_iu_t *)task->task_port_private;
994 ASSERT(iu != NULL);
995
996 mutex_enter(&iu->iu_lock);
997
998 /*
999 * If no I/O is outstanding then immediately transition to
1000 * aborted state. If any I/O is in progress OR we've sent the
1001 * completion response, then indicate that an STMF abort has been
1002 * requested and ask STMF to call us back later to complete the abort.
1003 */
1004 if ((iu->iu_flags & SRPT_IU_RESP_SENT) ||
1005 (iu->iu_sq_posted_cnt > 0)) {
1006 SRPT_DPRINTF_L3("stp_abort, deferring abort request. "
1007 "%d outstanding I/O for IU %p",
1008 iu->iu_sq_posted_cnt, (void *)iu);
1009 iu->iu_flags |= SRPT_IU_STMF_ABORTING;
1010 status = STMF_BUSY;
1011 } else {
1012 SRPT_DPRINTF_L3("stp_abort, no outstanding I/O for %p",
1013 (void *)iu);
1014 iu->iu_flags |= SRPT_IU_ABORTED;
1015 /* Synchronous abort - STMF will call task_free */
1016 status = STMF_ABORT_SUCCESS;
1017 }
1018
1019 mutex_exit(&iu->iu_lock);
1020 return (status);
1021 }
1022
1023 /*
1024 * srpt_stp_task_poll() - STMF call-back
1025 */
1026 static void
1027 srpt_stp_task_poll(struct scsi_task *task)
1028 {
1029 SRPT_DPRINTF_L3("stp_task_poll, invoked, task (%p)",
1030 (void *)task);
1031 }
1032
1033 /*
1034 * srpt_stp_ctl() - STMF call-back
1035 */
1036 static void
1037 srpt_stp_ctl(struct stmf_local_port *lport, int cmd, void *arg)
1038 {
1039 stmf_state_change_info_t *sc_info = arg;
1040 stmf_change_status_t cstatus;
1041 stmf_status_t status;
1042 srpt_target_port_t *tgt;
1043 char *why;
1044
1045 ASSERT(sc_info != NULL);
1046 ASSERT(lport != NULL);
1047
1048 tgt = lport->lport_port_private;
1049 ASSERT(tgt->tp_ioc != NULL);
1050
1051 why = sc_info->st_additional_info;
1052 if (why == NULL) {
1053 why = "<null>";
1054 }
1055
1056 SRPT_DPRINTF_L2("stp_ctl, invoked for LPORT (0x%016llx), cmd (%d), "
1057 "info (%s)", (u_longlong_t)tgt->tp_ibt_svc_id, cmd, why);
1058
1059 cstatus.st_completion_status = STMF_SUCCESS;
1060 cstatus.st_additional_info = NULL;
1061
1062 switch (cmd) {
1063 case STMF_CMD_LPORT_ONLINE:
1064 SRPT_DPRINTF_L2("stp_ctl, LPORT_ONLINE command,"
1065 " st_rflags(0x%llx)", (u_longlong_t)sc_info->st_rflags);
1066 /*
1067 * If the SCSI Target Port is not enabled by the driver,
1068 * don't start and instead return busy. This is a
1069 * creation/destruction transitional state and the will
1070 * either go away or become enabled.
1071 */
1072 mutex_enter(&tgt->tp_lock);
1073
1074 tgt->tp_requested_state = SRPT_TGT_STATE_ONLINE;
1075
1076 if (tgt->tp_drv_disabled != 0) {
1077 SRPT_DPRINTF_L1("stp_ctl, set LPORT_ONLINE failed - "
1078 "LPORT (0x%016llx) BUSY",
1079 (u_longlong_t)tgt->tp_ibt_svc_id);
1080 cstatus.st_completion_status = STMF_BUSY;
1081 } else if ((tgt->tp_state == SRPT_TGT_STATE_ONLINE) ||
1082 (tgt->tp_state == SRPT_TGT_STATE_ONLINING)) {
1083 cstatus.st_completion_status = STMF_ALREADY;
1084 } else if (tgt->tp_state != SRPT_TGT_STATE_OFFLINE) {
1085 cstatus.st_completion_status = STMF_INVALID_ARG;
1086 } else {
1087 tgt->tp_state = SRPT_TGT_STATE_ONLINING;
1088 status = srpt_stp_start_srp(tgt);
1089 if (status != IBT_SUCCESS) {
1090 tgt->tp_state = SRPT_TGT_STATE_OFFLINE;
1091 cstatus.st_completion_status = STMF_INVALID_ARG;
1092 if (tgt->tp_num_active_ports == 0) {
1093 SRPT_DPRINTF_L1(
1094 "stp_ctl, no ports active "
1095 "for HCA 0x%016llx. Target will "
1096 "not be placed online.",
1097 (u_longlong_t)tgt->tp_ibt_svc_id);
1098 }
1099 }
1100 }
1101 mutex_exit(&tgt->tp_lock);
1102 SRPT_DPRINTF_L3("stp_ctl, (0x%016llx) LPORT_ONLINE command"
1103 " status (0x%llx)", (u_longlong_t)tgt->tp_ibt_svc_id,
1104 (u_longlong_t)cstatus.st_completion_status);
1105 status = stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE, lport,
1106 &cstatus);
1107 if (status != STMF_SUCCESS) {
1108 SRPT_DPRINTF_L1("stp_ctl, ONLINE_COMPLETE returned"
1109 " error(0x%llx)", (u_longlong_t)status);
1110 }
1111 break;
1112
1113 case STMF_CMD_LPORT_OFFLINE:
1114 SRPT_DPRINTF_L2("stp_ctl, LPORT_OFFLINE command,"
1115 " st_rflags(0x%llx)", (u_longlong_t)sc_info->st_rflags);
1116 mutex_enter(&tgt->tp_lock);
1117
1118 /*
1119 * Only keep persistent state if explicitly requested by user
1120 * action, such as stmfadm offline-target or
1121 * svcadm disable stmf.
1122 * If not requested by the user, this was likely triggered by
1123 * not having any HCA ports active.
1124 */
1125 if (sc_info->st_rflags & STMF_RFLAG_USER_REQUEST) {
1126 tgt->tp_requested_state = SRPT_TGT_STATE_OFFLINE;
1127 }
1128
1129 if ((tgt->tp_state == SRPT_TGT_STATE_OFFLINE) ||
1130 (tgt->tp_state == SRPT_TGT_STATE_OFFLINING)) {
1131 cstatus.st_completion_status = STMF_ALREADY;
1132 } else if (tgt->tp_state != SRPT_TGT_STATE_ONLINE) {
1133 cstatus.st_completion_status = STMF_INVALID_ARG;
1134 } else {
1135 tgt->tp_state = SRPT_TGT_STATE_OFFLINING;
1136 srpt_stp_stop_srp(tgt);
1137 }
1138 mutex_exit(&tgt->tp_lock);
1139 SRPT_DPRINTF_L3("stp_ctl, notify STMF OFFLINE complete"
1140 " (0x%016llx)", (u_longlong_t)tgt->tp_ibt_svc_id);
1141 status = stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE,
1142 lport, &cstatus);
1143 if (status != STMF_SUCCESS) {
1144 SRPT_DPRINTF_L1("stp_ctl, OFFLINE_COMPLETE returned"
1145 " error(0x%llx)", (u_longlong_t)status);
1146 }
1147 break;
1148
1149 case STMF_ACK_LPORT_ONLINE_COMPLETE:
1150 SRPT_DPRINTF_L2("stp_ctl, LPORT_ONLINE_COMPLETE ACK from"
1151 " STMF");
1152 mutex_enter(&tgt->tp_lock);
1153 if (tgt->tp_state == SRPT_TGT_STATE_ONLINING) {
1154 SRPT_DPRINTF_L2("stp_ctl, LPORT is ONLINE");
1155 tgt->tp_state = SRPT_TGT_STATE_ONLINE;
1156 } else {
1157 SRPT_DPRINTF_L2("stp_ctl, LPORT not on-lining");
1158 }
1159 mutex_exit(&tgt->tp_lock);
1160 break;
1161
1162 case STMF_ACK_LPORT_OFFLINE_COMPLETE:
1163 SRPT_DPRINTF_L2("stp_ctl, LPORT_OFFLINE_COMPLETE ACK from"
1164 " STMF");
1165 mutex_enter(&tgt->tp_lock);
1166 if (tgt->tp_state == SRPT_TGT_STATE_OFFLINING) {
1167 SRPT_DPRINTF_L2("stp_ctl, LPORT is OFFLINE");
1168 tgt->tp_state = SRPT_TGT_STATE_OFFLINE;
1169 cv_broadcast(&tgt->tp_offline_complete);
1170 } else {
1171 SRPT_DPRINTF_L2("stp_ctl, LPORT not off-lining");
1172 }
1173 mutex_exit(&tgt->tp_lock);
1174 break;
1175
1176 default:
1177 SRPT_DPRINTF_L2("stp_ctl, cmd (%d) not handled",
1178 cmd);
1179 break;
1180 }
1181 }
1182
1183 /*
1184 * srpt_stp_info() - STMF call-back
1185 */
1186 /* ARGSUSED */
1187 static stmf_status_t
1188 srpt_stp_info(uint32_t cmd, struct stmf_local_port *lport,
1189 void *arg, uint8_t *buf, uint32_t *bufsizep)
1190 {
1191 SRPT_DPRINTF_L3("stp_info, invoked");
1192 return (STMF_SUCCESS);
1193 }
1194
1195 /*
1196 * srpt_stp_event_handler() - STMF call-back
1197 */
1198 /* ARGSUSED */
1199 static void
1200 srpt_stp_event_handler(struct stmf_local_port *lport, int eventid,
1201 void *arg, uint32_t flags)
1202 {
1203 SRPT_DPRINTF_L3("stp_event_handler, invoked");
1204 }
1205
1206 /*
1207 * srpt_stp_alloc_scsi_devid_desc()
1208 *
1209 * Allocate and initialize a SCSI device ID descriptor for
1210 * the SRP protocol. Names are eui.GUID format.
1211 *
1212 * Both extension and guid are passed in host order.
1213 */
1214 static scsi_devid_desc_t *
1215 srpt_stp_alloc_scsi_devid_desc(uint64_t guid)
1216 {
1217 scsi_devid_desc_t *sdd;
1218
1219 sdd = kmem_zalloc(sizeof (*sdd) + SRPT_EUI_ID_LEN + 1, KM_SLEEP);
1220 sdd->protocol_id = PROTOCOL_SRP;
1221 sdd->piv = 1;
1222 sdd->code_set = CODE_SET_ASCII;
1223 sdd->association = ID_IS_TARGET_PORT;
1224 sdd->ident_length = SRPT_EUI_ID_LEN;
1225 (void) sprintf((char *)sdd->ident, "eui.%016llX", (u_longlong_t)guid);
1226 return (sdd);
1227 }
1228
1229 /*
1230 * srpt_stp_free_scsi_devid_desc()
1231 *
1232 * Free a SRPT SCSI device ID descriptor previously allocated via
1233 * srpt_stp_alloc_scsi_devid_desc().
1234 */
1235 static void
1236 srpt_stp_free_scsi_devid_desc(scsi_devid_desc_t *sdd)
1237 {
1238 kmem_free(sdd, sizeof (*sdd) + SRPT_EUI_ID_LEN + 1);
1239 }
1240
1241 /*
1242 * srpt_stp_alloc_session()
1243 */
1244 srpt_session_t *
1245 srpt_stp_alloc_session(srpt_target_port_t *tgt,
1246 uint8_t *i_id, uint8_t *t_id, uint8_t port,
1247 char *local_gid, char *remote_gid)
1248 {
1249 stmf_status_t status;
1250 srpt_session_t *ss;
1251 stmf_scsi_session_t *stmf_ss;
1252 uint64_t i_guid;
1253 scsi_srp_transport_id_t *srptpd;
1254
1255 ASSERT(tgt != NULL);
1256 SRPT_DPRINTF_L3("stp_alloc_session, invoked");
1257
1258 mutex_enter(&tgt->tp_sess_list_lock);
1259
1260 i_guid = BE_IN64(&i_id[8]);
1261
1262 stmf_ss = stmf_alloc(STMF_STRUCT_SCSI_SESSION,
1263 sizeof (srpt_session_t), 0);
1264 if (stmf_ss == NULL) {
1265 SRPT_DPRINTF_L2("stp_alloc_session, stmf_alloc"
1266 " returned NULL");
1267 mutex_exit(&tgt->tp_sess_list_lock);
1268 return (NULL);
1269 }
1270 ss = stmf_ss->ss_port_private;
1271 ASSERT(ss != NULL);
1272
1273 rw_init(&ss->ss_rwlock, NULL, RW_DRIVER, NULL);
1274 list_create(&ss->ss_task_list, sizeof (srpt_iu_t),
1275 offsetof(srpt_iu_t, iu_ss_task_node));
1276
1277 stmf_ss->ss_rport_id = srpt_stp_alloc_scsi_devid_desc(i_guid);
1278 /* Setup remote port transport id */
1279 stmf_ss->ss_rport = stmf_remote_port_alloc(
1280 sizeof (scsi_srp_transport_id_t));
1281 stmf_ss->ss_rport->rport_tptid->protocol_id = PROTOCOL_SRP;
1282 stmf_ss->ss_rport->rport_tptid->format_code = 0;
1283 srptpd = (scsi_srp_transport_id_t *)stmf_ss->ss_rport->rport_tptid;
1284 bcopy(i_id, srptpd->srp_name, SRP_PORT_ID_LEN);
1285
1286 stmf_ss->ss_lport = tgt->tp_lport;
1287
1288 ss->ss_ss = stmf_ss;
1289 ss->ss_hw_port = port;
1290 ss->ss_tgt = tgt;
1291 bcopy(i_id, ss->ss_i_id, SRP_PORT_ID_LEN);
1292 bcopy(t_id, ss->ss_t_id, SRP_PORT_ID_LEN);
1293
1294 /*
1295 * Set the alias to include the initiator extension, this will enable
1296 * the administrator to identify multiple unique sessions originating
1297 * from the same initiator.
1298 */
1299 (void) strlcpy(ss->ss_i_gid, remote_gid, SRPT_ALIAS_LEN);
1300 (void) strlcpy(ss->ss_t_gid, local_gid, SRPT_ALIAS_LEN);
1301 EUI_STR(ss->ss_i_name, BE_IN64(&ss->ss_i_id[8]));
1302 EUI_STR(ss->ss_t_name, BE_IN64(&ss->ss_t_id[0]));
1303 ALIAS_STR(ss->ss_i_alias, BE_IN64(&ss->ss_i_id[0]),
1304 BE_IN64(&ss->ss_i_id[8]));
1305 ALIAS_STR(ss->ss_t_alias, BE_IN64(&ss->ss_t_id[0]),
1306 BE_IN64(&ss->ss_t_id[8]));
1307 stmf_ss->ss_rport_alias = ss->ss_i_alias;
1308
1309 status = stmf_register_scsi_session(tgt->tp_lport, stmf_ss);
1310 if (status != STMF_SUCCESS) {
1311 SRPT_DPRINTF_L1("stp_alloc_session, STMF register session"
1312 " err(0x%llx)", (u_longlong_t)status);
1313 list_destroy(&ss->ss_task_list);
1314 rw_destroy(&ss->ss_rwlock);
1315 srpt_stp_free_scsi_devid_desc(stmf_ss->ss_rport_id);
1316 stmf_remote_port_free(stmf_ss->ss_rport);
1317 stmf_free(stmf_ss);
1318 mutex_exit(&tgt->tp_sess_list_lock);
1319 return (NULL);
1320 }
1321
1322 list_insert_tail(&tgt->tp_sess_list, ss);
1323 mutex_exit(&tgt->tp_sess_list_lock);
1324 return (ss);
1325 }
1326
1327 /*
1328 * srpt_stp_free_session()
1329 */
1330 void
1331 srpt_stp_free_session(srpt_session_t *session)
1332 {
1333 stmf_scsi_session_t *stmf_ss;
1334 srpt_target_port_t *tgt;
1335
1336 ASSERT(session != NULL);
1337
1338 tgt = session->ss_tgt;
1339
1340 ASSERT(tgt != NULL);
1341
1342 SRPT_DPRINTF_L3("stp_free_session, invoked");
1343
1344 mutex_enter(&tgt->tp_sess_list_lock);
1345
1346 stmf_ss = session->ss_ss;
1347
1348 list_destroy(&session->ss_task_list);
1349 rw_destroy(&session->ss_rwlock);
1350
1351 stmf_deregister_scsi_session(tgt->tp_lport, stmf_ss);
1352 srpt_stp_free_scsi_devid_desc(stmf_ss->ss_rport_id);
1353 stmf_remote_port_free(stmf_ss->ss_rport);
1354 list_remove(&tgt->tp_sess_list, session);
1355 cv_signal(&tgt->tp_sess_complete);
1356 mutex_exit(&tgt->tp_sess_list_lock);
1357 stmf_free(stmf_ss);
1358 }
1359
1360 /*
1361 * srpt_stp_login() - SRP SCSI Target port login
1362 */
1363 srpt_channel_t *
1364 srpt_stp_login(srpt_target_port_t *tgt, srp_login_req_t *login,
1365 srp_login_rsp_t *login_rsp, srp_login_rej_t *login_rej,
1366 uint8_t login_port, char *local_gid, char *remote_gid)
1367 {
1368 uint32_t reason;
1369 uint32_t req_it_ui_len;
1370 uint8_t rsp_flags;
1371 srpt_ioc_t *ioc;
1372 srpt_channel_t *ch = NULL;
1373 srpt_channel_t *next_ch = NULL;
1374 srpt_session_t *session = NULL;
1375 srpt_session_t sess;
1376
1377 ASSERT(tgt != NULL);
1378 ASSERT(login != NULL);
1379 ASSERT(login_rsp != NULL);
1380 ASSERT(login_rej != NULL);
1381
1382 /* Store the string representation of connection info */
1383 /* for Dtrace probes */
1384 bzero(&sess, sizeof (srpt_session_t));
1385 (void) strlcpy(sess.ss_i_gid, remote_gid, SRPT_ALIAS_LEN);
1386 (void) strlcpy(sess.ss_t_gid, local_gid, SRPT_ALIAS_LEN);
1387 EUI_STR(sess.ss_i_name,
1388 BE_IN64(&login->lreq_initiator_port_id[8]));
1389 EUI_STR(sess.ss_t_name,
1390 BE_IN64(&login->lreq_target_port_id[0]));
1391 ALIAS_STR(sess.ss_i_alias,
1392 BE_IN64(&login->lreq_initiator_port_id[0]),
1393 BE_IN64(&login->lreq_initiator_port_id[8]));
1394 ALIAS_STR(sess.ss_t_alias,
1395 BE_IN64(&login->lreq_target_port_id[0]),
1396 BE_IN64(&login->lreq_target_port_id[8]));
1397
1398 DTRACE_SRP_2(login__command, srpt_session_t, &sess,
1399 srp_login_req_t, login);
1400
1401 /*
1402 * The target lock taken here serializes logins to this target
1403 * and prevents an STMF target port from starting a control
1404 * operation to transition the target state while a login is
1405 * being processed.
1406 */
1407 bzero(login_rsp, sizeof (srp_login_rsp_t));
1408 bzero(login_rej, sizeof (srp_login_rej_t));
1409 mutex_enter(&tgt->tp_lock);
1410 ioc = tgt->tp_ioc;
1411 if (ioc == NULL) {
1412 SRPT_DPRINTF_L1("stp_login, NULL I/O Controller");
1413 reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
1414 goto reject_login;
1415 }
1416
1417 /*
1418 * Validate that the SRP Target ID in the login request specifies
1419 * this I/O Controller SCSI Target Port.
1420 */
1421 if (memcmp(login->lreq_target_port_id, tgt->tp_srp_port_id,
1422 SRP_PORT_ID_LEN) != 0) {
1423 SRPT_DPRINTF_L2("stp_login, SRP CM SVC target ID mismatch."
1424 " Incoming TgtID 0x%016llx:0x%016llx",
1425 (u_longlong_t)BE_IN64(&login->lreq_target_port_id[0]),
1426 (u_longlong_t)BE_IN64(&login->lreq_target_port_id[8]));
1427
1428 reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
1429 goto reject_login;
1430 }
1431
1432 if (tgt->tp_state != SRPT_TGT_STATE_ONLINE) {
1433 SRPT_DPRINTF_L2("stp_login, SRP Login target not on-line");
1434 reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
1435 goto reject_login;
1436 }
1437
1438 /*
1439 * Initiator requested IU size must be as large as the specification
1440 * minimum and no greater than what we chose to support.
1441 */
1442 req_it_ui_len = b2h32(login->lreq_req_it_iu_len);
1443 SRPT_DPRINTF_L2("stp_login, requested iu size = %d", req_it_ui_len);
1444 if (req_it_ui_len > srpt_iu_size) {
1445 SRPT_DPRINTF_L2("stp_login, SRP Login IU size (%d) too large",
1446 req_it_ui_len);
1447 reason = SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE;
1448 goto reject_login;
1449 }
1450 if (req_it_ui_len < SRP_MIN_IU_SIZE) {
1451 SRPT_DPRINTF_L2("stp_login, SRP Login IU size (%d) too small",
1452 req_it_ui_len);
1453 reason = SRP_LOGIN_REJ_NO_REASON;
1454 goto reject_login;
1455 }
1456
1457 SRPT_DPRINTF_L2("stp_login, login req InitID 0x%016llx:0x%016llx",
1458 (u_longlong_t)BE_IN64(&login->lreq_initiator_port_id[0]),
1459 (u_longlong_t)BE_IN64(&login->lreq_initiator_port_id[8]));
1460 SRPT_DPRINTF_L2("stp_login, login req TgtID 0x%016llx:0x%016llx",
1461 (u_longlong_t)BE_IN64(&login->lreq_target_port_id[0]),
1462 (u_longlong_t)BE_IN64(&login->lreq_target_port_id[8]));
1463
1464 /*
1465 * Processing is based on either single channel or multi-channel
1466 * operation. In single channel, all current logins for this
1467 * same I_T_Nexus should be logged out. In multi-channel
1468 * mode we would add an additional channel to an existing
1469 * I_T_Nexus if one currently exists (i.e. reference the
1470 * same SCSI session).
1471 */
1472 rsp_flags = SRP_MULTI_CH_RESULT_NO_EXISTING;
1473
1474 switch (login->lreq_req_flags & SRP_LOGIN_MULTI_CH_MASK) {
1475
1476 case SRP_LOGIN_MULTI_CH_SINGLE:
1477 /*
1478 * Only a single channel may be associated with a I_T_Nexus.
1479 * Disconnect any channel with the same SRP Initiator and
1480 * SRP target IDs.
1481 */
1482 mutex_enter(&tgt->tp_ch_list_lock);
1483 ch = list_head(&tgt->tp_ch_list);
1484 while (ch != NULL) {
1485 SRPT_DPRINTF_L3("stp_login, compare session,"
1486 " ch_state(%d)", ch->ch_state);
1487 next_ch = list_next(&tgt->tp_ch_list, ch);
1488
1489 if (ch->ch_state != SRPT_CHANNEL_CONNECTING &&
1490 ch->ch_state != SRPT_CHANNEL_CONNECTED) {
1491 SRPT_DPRINTF_L3("stp_login, compare session,"
1492 " channel not active");
1493 ch = next_ch;
1494 continue;
1495 }
1496
1497 ASSERT(ch->ch_session != NULL);
1498 SRPT_DPRINTF_L3("stp_login, compare session"
1499 " I_ID 0x%016llx:0x%016llx",
1500 (u_longlong_t)b2h64(*((uint64_t *)(void *)
1501 &ch->ch_session->ss_i_id[0])),
1502 (u_longlong_t)b2h64(*((uint64_t *)(void *)
1503 &ch->ch_session->ss_i_id[8])));
1504 SRPT_DPRINTF_L3("stp_login, compare session"
1505 " T_ID 0x%016llx:0x%016llx",
1506 (u_longlong_t)b2h64(*((uint64_t *)(void *)
1507 &ch->ch_session->ss_t_id[0])),
1508 (u_longlong_t)b2h64(*((uint64_t *)(void *)
1509 &ch->ch_session->ss_t_id[8])));
1510 if ((bcmp(login->lreq_initiator_port_id,
1511 ch->ch_session->ss_i_id,
1512 SRP_PORT_ID_LEN) == 0) &&
1513 (bcmp(login->lreq_target_port_id,
1514 ch->ch_session->ss_t_id,
1515 SRP_PORT_ID_LEN) == 0)) {
1516 /*
1517 * if a session is in the process of connecting,
1518 * reject subsequent equivalent requests.
1519 */
1520 if (ch->ch_state == SRPT_CHANNEL_CONNECTING) {
1521 reason = SRP_LOGIN_REJ_INIT_CH_LIMIT;
1522 mutex_exit(&tgt->tp_ch_list_lock);
1523 goto reject_login;
1524 }
1525
1526 SRPT_DPRINTF_L2("stp_login, terminate"
1527 " existing login");
1528 rsp_flags =
1529 SRP_MULTI_CH_RESULT_TERM_EXISTING;
1530 srpt_ch_disconnect(ch);
1531 }
1532
1533 ch = next_ch;
1534 }
1535 mutex_exit(&tgt->tp_ch_list_lock);
1536
1537 /* Create the new session for this SRP login */
1538 session = srpt_stp_alloc_session(tgt,
1539 login->lreq_initiator_port_id,
1540 login->lreq_target_port_id, login_port,
1541 local_gid, remote_gid);
1542 if (session == NULL) {
1543 SRPT_DPRINTF_L2("stp_login, session allocation"
1544 " failed");
1545 reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
1546 goto reject_login;
1547 }
1548 break;
1549
1550 case SRP_LOGIN_MULTI_CH_MULTIPLE:
1551 SRPT_DPRINTF_L2("stp_login, multichannel not supported yet");
1552 reason = SRP_LOGIN_REJ_MULTI_CH_NOT_SUPPORTED;
1553 goto reject_login;
1554 /* break via goto */
1555
1556 default:
1557 SRPT_DPRINTF_L2("stp_login, invalid multichannel field (%d)",
1558 login->lreq_req_flags & SRP_LOGIN_MULTI_CH_MASK);
1559 reason = SRP_LOGIN_REJ_NO_REASON;
1560 goto reject_login;
1561 /* break via goto */
1562 }
1563
1564 /*
1565 * Create new RDMA channel for this SRP login request.
1566 * The channel is returned with a single reference which
1567 * represents the reference held by the CM.
1568 */
1569 ch = srpt_ch_alloc(tgt, login_port);
1570 if (ch == NULL) {
1571 SRPT_DPRINTF_L2("stp_login, unable to alloc RDMA channel");
1572 reason = SRP_LOGIN_REJ_INSUFFICIENT_CH_RESOURCES;
1573 srpt_stp_free_session(session);
1574 goto reject_login;
1575 }
1576 ch->ch_session = session;
1577 ch->ch_ti_iu_len = b2h32(login->lreq_req_it_iu_len);
1578
1579 /*
1580 * Add another reference to the channel which represents
1581 * a reference placed by the target port and add it to
1582 * the store of channels logged in for this target port.
1583 */
1584 srpt_ch_add_ref(ch);
1585 mutex_enter(&tgt->tp_ch_list_lock);
1586 list_insert_tail(&tgt->tp_ch_list, ch);
1587 mutex_exit(&tgt->tp_ch_list_lock);
1588
1589 srpt_format_login_rsp(login, login_rsp, rsp_flags);
1590 mutex_exit(&tgt->tp_lock);
1591 SRPT_DPRINTF_L2("stp_login, login successful");
1592
1593 DTRACE_SRP_3(login__response, srpt_session_t, &sess,
1594 srp_login_rsp_t, login_rsp, srp_login_rej_t, login_rej)
1595
1596 return (ch);
1597
1598 reject_login:
1599 srpt_format_login_rej(login, login_rej, reason);
1600 mutex_exit(&tgt->tp_lock);
1601
1602 DTRACE_SRP_3(login__response, srpt_session_t, &sess,
1603 srp_login_rsp_t, login_rsp, srp_login_rej_t, login_rej);
1604
1605 return (NULL);
1606 }
1607
1608 /*
1609 * srpt_stp_logout() - SRP logout
1610 *
1611 * Logout is not normally initiated in-band, but is so, just
1612 * initiate a disconnect.
1613 */
1614 void
1615 srpt_stp_logout(srpt_channel_t *ch)
1616 {
1617 DTRACE_SRP_1(logout__command, srpt_channel_t, ch);
1618 SRPT_DPRINTF_L2("stp_logout, invoked for ch (%p)", (void *)ch);
1619 srpt_ch_disconnect(ch);
1620 }
1621
1622 /*
1623 * srpt_format_login_rej() - Format login reject IU
1624 */
1625 static void
1626 srpt_format_login_rej(srp_login_req_t *req, srp_login_rej_t *rej,
1627 uint32_t reason)
1628 {
1629 rej->lrej_type = SRP_IU_LOGIN_REJ;
1630 rej->lrej_reason = h2b32(reason);
1631 rej->lrej_tag = req->lreq_tag;
1632 rej->lrej_sup_buf_format =
1633 h2b16(SRP_DIRECT_BUFR_DESC | SRP_INDIRECT_BUFR_DESC);
1634 }
1635
1636 /*
1637 * srpt_format_login_rsp() - Format login response IU
1638 */
1639 static void
1640 srpt_format_login_rsp(srp_login_req_t *req, srp_login_rsp_t *rsp,
1641 uint8_t flags)
1642 {
1643 rsp->lrsp_type = SRP_IU_LOGIN_RSP;
1644 rsp->lrsp_req_limit_delta = h2b32((uint32_t)srpt_send_msg_depth);
1645 rsp->lrsp_tag = req->lreq_tag;
1646
1647 rsp->lrsp_max_it_iu_len = req->lreq_req_it_iu_len;
1648 /* by def. > min T_IU_LEN */
1649 rsp->lrsp_max_ti_iu_len = req->lreq_req_it_iu_len;
1650
1651 rsp->lrsp_sup_buf_format =
1652 h2b16(SRP_DIRECT_BUFR_DESC | SRP_INDIRECT_BUFR_DESC);
1653 rsp->lrsp_rsp_flags = flags;
1654 }
1655
1656 /*
1657 * srpt_stp_add_task()
1658 */
1659 void
1660 srpt_stp_add_task(srpt_session_t *session, srpt_iu_t *iu)
1661 {
1662 rw_enter(&session->ss_rwlock, RW_WRITER);
1663 list_insert_tail(&session->ss_task_list, iu);
1664 rw_exit(&session->ss_rwlock);
1665 }
1666
1667 /*
1668 * srpt_stp_remove_task()
1669 */
1670 void
1671 srpt_stp_remove_task(srpt_session_t *session, srpt_iu_t *iu)
1672 {
1673 rw_enter(&session->ss_rwlock, RW_WRITER);
1674
1675 ASSERT(!list_is_empty(&session->ss_task_list));
1676
1677 list_remove(&session->ss_task_list, iu);
1678 rw_exit(&session->ss_rwlock);
1679 }