?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
16615 ena assertion failure in ena_tx_intr_work()
[illumos-gate.git] / usr / src / uts / common / io / comstar / port / iscsit / iscsit.c
blob1a3483f1897cac66216e89b3821c4d40e5eb1c60
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 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23 *
24 * Copyright 2017 Nexenta Systems, Inc.
25 * Copyright (c) 2017, Joyent, Inc. All rights reserved.
26 */
27
28 #include <sys/cpuvar.h>
29 #include <sys/types.h>
30 #include <sys/conf.h>
31 #include <sys/stat.h>
32 #include <sys/file.h>
33 #include <sys/ddi.h>
34 #include <sys/sunddi.h>
35 #include <sys/modctl.h>
36 #include <sys/sysmacros.h>
37 #include <sys/socket.h>
38 #include <sys/strsubr.h>
39 #include <sys/nvpair.h>
40
41 #include <sys/stmf.h>
42 #include <sys/stmf_ioctl.h>
43 #include <sys/portif.h>
44 #include <sys/idm/idm.h>
45 #include <sys/idm/idm_conn_sm.h>
46
47 #include "iscsit_isns.h"
48 #include "iscsit.h"
49
50 #define ISCSIT_VERSION BUILD_DATE "-1.18dev"
51 #define ISCSIT_NAME_VERSION "COMSTAR ISCSIT v" ISCSIT_VERSION
52
53 /*
54 * DDI entry points.
55 */
56 static int iscsit_drv_attach(dev_info_t *, ddi_attach_cmd_t);
57 static int iscsit_drv_detach(dev_info_t *, ddi_detach_cmd_t);
58 static int iscsit_drv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
59 static int iscsit_drv_open(dev_t *, int, int, cred_t *);
60 static int iscsit_drv_close(dev_t, int, int, cred_t *);
61 static boolean_t iscsit_drv_busy(void);
62 static int iscsit_drv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
63
64 extern struct mod_ops mod_miscops;
65
66
67 static struct cb_ops iscsit_cb_ops = {
68 iscsit_drv_open, /* cb_open */
69 iscsit_drv_close, /* cb_close */
70 nodev, /* cb_strategy */
71 nodev, /* cb_print */
72 nodev, /* cb_dump */
73 nodev, /* cb_read */
74 nodev, /* cb_write */
75 iscsit_drv_ioctl, /* cb_ioctl */
76 nodev, /* cb_devmap */
77 nodev, /* cb_mmap */
78 nodev, /* cb_segmap */
79 nochpoll, /* cb_chpoll */
80 ddi_prop_op, /* cb_prop_op */
81 NULL, /* cb_streamtab */
82 D_MP, /* cb_flag */
83 CB_REV, /* cb_rev */
84 nodev, /* cb_aread */
85 nodev, /* cb_awrite */
86 };
87
88 static struct dev_ops iscsit_dev_ops = {
89 DEVO_REV, /* devo_rev */
90 0, /* devo_refcnt */
91 iscsit_drv_getinfo, /* devo_getinfo */
92 nulldev, /* devo_identify */
93 nulldev, /* devo_probe */
94 iscsit_drv_attach, /* devo_attach */
95 iscsit_drv_detach, /* devo_detach */
96 nodev, /* devo_reset */
97 &iscsit_cb_ops, /* devo_cb_ops */
98 NULL, /* devo_bus_ops */
99 NULL, /* devo_power */
100 ddi_quiesce_not_needed, /* quiesce */
101 };
102
103 static struct modldrv modldrv = {
104 &mod_driverops,
105 "iSCSI Target",
106 &iscsit_dev_ops,
107 };
108
109 static struct modlinkage modlinkage = {
110 MODREV_1,
111 &modldrv,
112 NULL,
113 };
114
115
116 iscsit_global_t iscsit_global;
117
118 kmem_cache_t *iscsit_status_pdu_cache;
119
120 boolean_t iscsit_sm_logging = B_FALSE;
121
122 kmutex_t login_sm_session_mutex;
123
124 static idm_status_t iscsit_init(dev_info_t *dip);
125 static idm_status_t iscsit_enable_svc(iscsit_hostinfo_t *hostinfo);
126 static void iscsit_disable_svc(void);
127
128 static boolean_t
129 iscsit_check_cmdsn_and_queue(idm_pdu_t *rx_pdu);
130
131 static void
132 iscsit_add_pdu_to_queue(iscsit_sess_t *ist, idm_pdu_t *rx_pdu);
133
134 static idm_pdu_t *
135 iscsit_remove_pdu_from_queue(iscsit_sess_t *ist, uint32_t cmdsn);
136
137 static void
138 iscsit_process_pdu_in_queue(iscsit_sess_t *ist);
139
140 static void
141 iscsit_rxpdu_queue_monitor_session(iscsit_sess_t *ist);
142
143 static void
144 iscsit_rxpdu_queue_monitor(void *arg);
145
146 static void
147 iscsit_post_staged_pdu(idm_pdu_t *rx_pdu);
148
149 static void
150 iscsit_post_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu);
151
152 static void
153 iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
154
155 static void
156 iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
157
158 static void
159 iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
160
161 void
162 iscsit_pdu_op_text_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
163
164 static void
165 iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
166
167 int iscsit_cmd_window();
168
169 static int
170 iscsit_sna_lt(uint32_t sn1, uint32_t sn2);
171
172 void
173 iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
174
175 static void
176 iscsit_deferred_dispatch(idm_pdu_t *rx_pdu);
177
178 static void
179 iscsit_deferred(void *rx_pdu_void);
180
181 static idm_status_t
182 iscsit_conn_accept(idm_conn_t *ic);
183
184 static idm_status_t
185 iscsit_ffp_enabled(idm_conn_t *ic);
186
187 static idm_status_t
188 iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class);
189
190 static idm_status_t
191 iscsit_conn_lost(idm_conn_t *ic);
192
193 static idm_status_t
194 iscsit_conn_destroy(idm_conn_t *ic);
195
196 static stmf_data_buf_t *
197 iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize,
198 uint32_t flags);
199
200 static void
201 iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf);
202
203 static void
204 iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status);
205
206 static void
207 iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status);
208
209 static void
210 iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status);
211
212 static stmf_status_t
213 iscsit_idm_to_stmf(idm_status_t idmrc);
214
215 static iscsit_task_t *
216 iscsit_task_alloc(iscsit_conn_t *ict);
217
218 static void
219 iscsit_task_free(iscsit_task_t *itask);
220
221 static iscsit_task_t *
222 iscsit_tm_task_alloc(iscsit_conn_t *ict);
223
224 static void
225 iscsit_tm_task_free(iscsit_task_t *itask);
226
227 static idm_status_t
228 iscsit_task_start(iscsit_task_t *itask);
229
230 static void
231 iscsit_task_done(iscsit_task_t *itask);
232
233 static int
234 iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags);
235
236 static void
237 iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags);
238
239 static it_cfg_status_t
240 iscsit_config_merge(it_config_t *cfg);
241
242 static idm_status_t
243 iscsit_login_fail(idm_conn_t *ic);
244
245 static boolean_t iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn);
246 static void iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu,
247 uint8_t response, uint8_t cmd_status);
248 static void iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu,
249 uint8_t tm_status);
250
251 /*
252 * MC/S: Out-of-order commands are staged on a session-wide wait
253 * queue until a system-tunable threshold is reached. A separate
254 * thread is used to scan the staging queue on all the session,
255 * If a delayed PDU does not arrive within a timeout, the target
256 * will advance to the staged PDU that is next in sequence, skipping
257 * over the missing PDU(s) to go past a hole in the sequence.
258 */
259 volatile int rxpdu_queue_threshold = ISCSIT_RXPDU_QUEUE_THRESHOLD;
260
261 static kmutex_t iscsit_rxpdu_queue_monitor_mutex;
262 kthread_t *iscsit_rxpdu_queue_monitor_thr_id;
263 static kt_did_t iscsit_rxpdu_queue_monitor_thr_did;
264 static boolean_t iscsit_rxpdu_queue_monitor_thr_running;
265 static kcondvar_t iscsit_rxpdu_queue_monitor_cv;
266
267 int
268 _init(void)
269 {
270 int rc;
271
272 rw_init(&iscsit_global.global_rwlock, NULL, RW_DRIVER, NULL);
273 mutex_init(&iscsit_global.global_state_mutex, NULL,
274 MUTEX_DRIVER, NULL);
275 iscsit_global.global_svc_state = ISE_DETACHED;
276
277 mutex_init(&iscsit_rxpdu_queue_monitor_mutex, NULL,
278 MUTEX_DRIVER, NULL);
279 mutex_init(&login_sm_session_mutex, NULL, MUTEX_DRIVER, NULL);
280 iscsit_rxpdu_queue_monitor_thr_id = NULL;
281 iscsit_rxpdu_queue_monitor_thr_running = B_FALSE;
282 cv_init(&iscsit_rxpdu_queue_monitor_cv, NULL, CV_DEFAULT, NULL);
283
284 if ((rc = mod_install(&modlinkage)) != 0) {
285 mutex_destroy(&iscsit_global.global_state_mutex);
286 rw_destroy(&iscsit_global.global_rwlock);
287 return (rc);
288 }
289
290 return (rc);
291 }
292
293 int
294 _info(struct modinfo *modinfop)
295 {
296 return (mod_info(&modlinkage, modinfop));
297 }
298
299 int
300 _fini(void)
301 {
302 int rc;
303
304 rc = mod_remove(&modlinkage);
305
306 if (rc == 0) {
307 mutex_destroy(&iscsit_rxpdu_queue_monitor_mutex);
308 mutex_destroy(&login_sm_session_mutex);
309 cv_destroy(&iscsit_rxpdu_queue_monitor_cv);
310 mutex_destroy(&iscsit_global.global_state_mutex);
311 rw_destroy(&iscsit_global.global_rwlock);
312 }
313
314 return (rc);
315 }
316
317 /*
318 * DDI entry points.
319 */
320
321 /* ARGSUSED */
322 static int
323 iscsit_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
324 void **result)
325 {
326 ulong_t instance = getminor((dev_t)arg);
327
328 switch (cmd) {
329 case DDI_INFO_DEVT2DEVINFO:
330 *result = iscsit_global.global_dip;
331 return (DDI_SUCCESS);
332
333 case DDI_INFO_DEVT2INSTANCE:
334 *result = (void *)instance;
335 return (DDI_SUCCESS);
336
337 default:
338 break;
339 }
340
341 return (DDI_FAILURE);
342 }
343
344 static int
345 iscsit_drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
346 {
347 if (cmd != DDI_ATTACH) {
348 return (DDI_FAILURE);
349 }
350
351 if (ddi_get_instance(dip) != 0) {
352 /* we only allow instance 0 to attach */
353 return (DDI_FAILURE);
354 }
355
356 /* create the minor node */
357 if (ddi_create_minor_node(dip, ISCSIT_MODNAME, S_IFCHR, 0,
358 DDI_PSEUDO, 0) != DDI_SUCCESS) {
359 cmn_err(CE_WARN, "iscsit_drv_attach: "
360 "failed creating minor node");
361 return (DDI_FAILURE);
362 }
363
364 if (iscsit_init(dip) != IDM_STATUS_SUCCESS) {
365 cmn_err(CE_WARN, "iscsit_drv_attach: "
366 "failed to initialize");
367 ddi_remove_minor_node(dip, NULL);
368 return (DDI_FAILURE);
369 }
370
371 iscsit_global.global_svc_state = ISE_DISABLED;
372 iscsit_global.global_dip = dip;
373
374 return (DDI_SUCCESS);
375 }
376
377 /*ARGSUSED*/
378 static int
379 iscsit_drv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
380 {
381 if (cmd != DDI_DETACH)
382 return (DDI_FAILURE);
383
384 /*
385 * drv_detach is called in a context that owns the
386 * device node for the /dev/pseudo device. If this thread blocks
387 * for any resource, other threads that need the /dev/pseudo device
388 * may end up in a deadlock with this thread.Hence, we use a
389 * separate lock just for the structures that drv_detach needs
390 * to access.
391 */
392 mutex_enter(&iscsit_global.global_state_mutex);
393 if (iscsit_drv_busy()) {
394 mutex_exit(&iscsit_global.global_state_mutex);
395 return (EBUSY);
396 }
397
398 iscsit_global.global_dip = NULL;
399 ddi_remove_minor_node(dip, NULL);
400
401 ldi_ident_release(iscsit_global.global_li);
402 iscsit_global.global_svc_state = ISE_DETACHED;
403
404 mutex_exit(&iscsit_global.global_state_mutex);
405
406 return (DDI_SUCCESS);
407 }
408
409 /*ARGSUSED*/
410 static int
411 iscsit_drv_open(dev_t *devp, int flag, int otyp, cred_t *credp)
412 {
413 return (0);
414 }
415
416 /* ARGSUSED */
417 static int
418 iscsit_drv_close(dev_t dev, int flag, int otyp, cred_t *credp)
419 {
420 return (0);
421 }
422
423 static boolean_t
424 iscsit_drv_busy(void)
425 {
426 ASSERT(MUTEX_HELD(&iscsit_global.global_state_mutex));
427
428 switch (iscsit_global.global_svc_state) {
429 case ISE_DISABLED:
430 case ISE_DETACHED:
431 return (B_FALSE);
432 default:
433 return (B_TRUE);
434 }
435 /* NOTREACHED */
436 }
437
438 /* ARGSUSED */
439 static int
440 iscsit_drv_ioctl(dev_t drv, int cmd, intptr_t argp, int flag, cred_t *cred,
441 int *retval)
442 {
443 iscsit_ioc_set_config_t setcfg;
444 iscsit_ioc_set_config32_t setcfg32;
445 char *cfg_pnvlist = NULL;
446 nvlist_t *cfg_nvlist = NULL;
447 it_config_t *cfg = NULL;
448 idm_status_t idmrc;
449 int rc = 0;
450
451 if (drv_priv(cred) != 0) {
452 return (EPERM);
453 }
454
455 mutex_enter(&iscsit_global.global_state_mutex);
456
457 /*
458 * Validate ioctl requests against global service state
459 */
460 switch (iscsit_global.global_svc_state) {
461 case ISE_ENABLED:
462 if (cmd == ISCSIT_IOC_DISABLE_SVC) {
463 iscsit_global.global_svc_state = ISE_DISABLING;
464 } else if (cmd == ISCSIT_IOC_ENABLE_SVC) {
465 /* Already enabled */
466 mutex_exit(&iscsit_global.global_state_mutex);
467 return (0);
468 } else {
469 iscsit_global.global_svc_state = ISE_BUSY;
470 }
471 break;
472 case ISE_DISABLED:
473 if (cmd == ISCSIT_IOC_ENABLE_SVC) {
474 iscsit_global.global_svc_state = ISE_ENABLING;
475 } else if (cmd == ISCSIT_IOC_DISABLE_SVC) {
476 /* Already disabled */
477 mutex_exit(&iscsit_global.global_state_mutex);
478 return (0);
479 } else {
480 rc = EFAULT;
481 }
482 break;
483 case ISE_BUSY:
484 case ISE_ENABLING:
485 case ISE_DISABLING:
486 rc = EAGAIN;
487 break;
488 case ISE_DETACHED:
489 default:
490 rc = EFAULT;
491 break;
492 }
493
494 mutex_exit(&iscsit_global.global_state_mutex);
495 if (rc != 0)
496 return (rc);
497
498 /* Handle ioctl request (enable/disable have already been handled) */
499 switch (cmd) {
500 case ISCSIT_IOC_SET_CONFIG:
501 /* Any errors must set state back to ISE_ENABLED */
502 switch (ddi_model_convert_from(flag & FMODELS)) {
503 case DDI_MODEL_ILP32:
504 if (ddi_copyin((void *)argp, &setcfg32,
505 sizeof (iscsit_ioc_set_config32_t), flag) != 0) {
506 rc = EFAULT;
507 goto cleanup;
508 }
509
510 setcfg.set_cfg_pnvlist =
511 (char *)((uintptr_t)setcfg32.set_cfg_pnvlist);
512 setcfg.set_cfg_vers = setcfg32.set_cfg_vers;
513 setcfg.set_cfg_pnvlist_len =
514 setcfg32.set_cfg_pnvlist_len;
515 break;
516 case DDI_MODEL_NONE:
517 if (ddi_copyin((void *)argp, &setcfg,
518 sizeof (iscsit_ioc_set_config_t), flag) != 0) {
519 rc = EFAULT;
520 goto cleanup;
521 }
522 break;
523 default:
524 rc = EFAULT;
525 goto cleanup;
526 }
527
528 /* Check API version */
529 if (setcfg.set_cfg_vers != ISCSIT_API_VERS0) {
530 rc = EINVAL;
531 goto cleanup;
532 }
533
534 /* Config is in packed nvlist format so unpack it */
535 cfg_pnvlist = kmem_alloc(setcfg.set_cfg_pnvlist_len,
536 KM_SLEEP);
537 ASSERT(cfg_pnvlist != NULL);
538
539 if (ddi_copyin(setcfg.set_cfg_pnvlist, cfg_pnvlist,
540 setcfg.set_cfg_pnvlist_len, flag) != 0) {
541 rc = EFAULT;
542 goto cleanup;
543 }
544
545 rc = nvlist_unpack(cfg_pnvlist, setcfg.set_cfg_pnvlist_len,
546 &cfg_nvlist, KM_SLEEP);
547 if (rc != 0) {
548 goto cleanup;
549 }
550
551 /* Translate nvlist */
552 rc = it_nv_to_config(cfg_nvlist, &cfg);
553 if (rc != 0) {
554 cmn_err(CE_WARN, "Configuration is invalid");
555 goto cleanup;
556 }
557
558 /* Update config */
559 rc = iscsit_config_merge(cfg);
560 /* FALLTHROUGH */
561
562 cleanup:
563 if (cfg)
564 it_config_free_cmn(cfg);
565 if (cfg_pnvlist)
566 kmem_free(cfg_pnvlist, setcfg.set_cfg_pnvlist_len);
567 if (cfg_nvlist)
568 nvlist_free(cfg_nvlist);
569
570 /*
571 * Now that the reconfig is complete set our state back to
572 * enabled.
573 */
574 mutex_enter(&iscsit_global.global_state_mutex);
575 iscsit_global.global_svc_state = ISE_ENABLED;
576 mutex_exit(&iscsit_global.global_state_mutex);
577 break;
578 case ISCSIT_IOC_ENABLE_SVC: {
579 iscsit_hostinfo_t hostinfo;
580
581 if (ddi_copyin((void *)argp, &hostinfo.length,
582 sizeof (hostinfo.length), flag) != 0) {
583 mutex_enter(&iscsit_global.global_state_mutex);
584 iscsit_global.global_svc_state = ISE_DISABLED;
585 mutex_exit(&iscsit_global.global_state_mutex);
586 return (EFAULT);
587 }
588
589 if (hostinfo.length > sizeof (hostinfo.fqhn))
590 hostinfo.length = sizeof (hostinfo.fqhn);
591
592 if (ddi_copyin((void *)((caddr_t)argp +
593 sizeof (hostinfo.length)), &hostinfo.fqhn,
594 hostinfo.length, flag) != 0) {
595 mutex_enter(&iscsit_global.global_state_mutex);
596 iscsit_global.global_svc_state = ISE_DISABLED;
597 mutex_exit(&iscsit_global.global_state_mutex);
598 return (EFAULT);
599 }
600
601 idmrc = iscsit_enable_svc(&hostinfo);
602 mutex_enter(&iscsit_global.global_state_mutex);
603 if (idmrc == IDM_STATUS_SUCCESS) {
604 iscsit_global.global_svc_state = ISE_ENABLED;
605 } else {
606 rc = EIO;
607 iscsit_global.global_svc_state = ISE_DISABLED;
608 }
609 mutex_exit(&iscsit_global.global_state_mutex);
610 break;
611 }
612 case ISCSIT_IOC_DISABLE_SVC:
613 iscsit_disable_svc();
614 mutex_enter(&iscsit_global.global_state_mutex);
615 iscsit_global.global_svc_state = ISE_DISABLED;
616 mutex_exit(&iscsit_global.global_state_mutex);
617 break;
618
619 default:
620 rc = EINVAL;
621 mutex_enter(&iscsit_global.global_state_mutex);
622 iscsit_global.global_svc_state = ISE_ENABLED;
623 mutex_exit(&iscsit_global.global_state_mutex);
624 }
625
626 return (rc);
627 }
628
629 static idm_status_t
630 iscsit_init(dev_info_t *dip)
631 {
632 int rc;
633
634 rc = ldi_ident_from_dip(dip, &iscsit_global.global_li);
635 ASSERT(rc == 0); /* Failure indicates invalid argument */
636
637 iscsit_global.global_svc_state = ISE_DISABLED;
638
639 return (IDM_STATUS_SUCCESS);
640 }
641
642 /*
643 * iscsit_enable_svc
644 *
645 * registers all the configured targets and target portals with STMF
646 */
647 static idm_status_t
648 iscsit_enable_svc(iscsit_hostinfo_t *hostinfo)
649 {
650 stmf_port_provider_t *pp;
651 stmf_dbuf_store_t *dbuf_store;
652 boolean_t did_iscsit_isns_init;
653 idm_status_t retval = IDM_STATUS_SUCCESS;
654
655 ASSERT(iscsit_global.global_svc_state == ISE_ENABLING);
656
657 /*
658 * Make sure that can tell if we have partially allocated
659 * in case we need to exit and tear down anything allocated.
660 */
661 iscsit_global.global_tsih_pool = NULL;
662 iscsit_global.global_dbuf_store = NULL;
663 iscsit_status_pdu_cache = NULL;
664 pp = NULL;
665 iscsit_global.global_pp = NULL;
666 iscsit_global.global_default_tpg = NULL;
667 did_iscsit_isns_init = B_FALSE;
668 iscsit_global.global_dispatch_taskq = NULL;
669
670 /* Setup remaining fields in iscsit_global_t */
671 idm_refcnt_init(&iscsit_global.global_refcnt,
672 &iscsit_global);
673
674 avl_create(&iscsit_global.global_discovery_sessions,
675 iscsit_sess_avl_compare, sizeof (iscsit_sess_t),
676 offsetof(iscsit_sess_t, ist_tgt_ln));
677
678 avl_create(&iscsit_global.global_target_list,
679 iscsit_tgt_avl_compare, sizeof (iscsit_tgt_t),
680 offsetof(iscsit_tgt_t, target_global_ln));
681
682 list_create(&iscsit_global.global_deleted_target_list,
683 sizeof (iscsit_tgt_t),
684 offsetof(iscsit_tgt_t, target_global_deleted_ln));
685
686 avl_create(&iscsit_global.global_tpg_list,
687 iscsit_tpg_avl_compare, sizeof (iscsit_tpg_t),
688 offsetof(iscsit_tpg_t, tpg_global_ln));
689
690 avl_create(&iscsit_global.global_ini_list,
691 iscsit_ini_avl_compare, sizeof (iscsit_ini_t),
692 offsetof(iscsit_ini_t, ini_global_ln));
693
694 iscsit_global.global_tsih_pool = vmem_create("iscsit_tsih_pool",
695 (void *)1, ISCSI_MAX_TSIH, 1, NULL, NULL, NULL, 0,
696 VM_SLEEP | VMC_IDENTIFIER);
697
698 /*
699 * Setup STMF dbuf store. Our buffers are bound to a specific
700 * connection so we really can't let STMF cache buffers for us.
701 * Consequently we'll just allocate one global buffer store.
702 */
703 dbuf_store = stmf_alloc(STMF_STRUCT_DBUF_STORE, 0, 0);
704 if (dbuf_store == NULL) {
705 retval = IDM_STATUS_FAIL;
706 goto tear_down_and_return;
707 }
708 dbuf_store->ds_alloc_data_buf = iscsit_dbuf_alloc;
709 dbuf_store->ds_free_data_buf = iscsit_dbuf_free;
710 dbuf_store->ds_port_private = NULL;
711 iscsit_global.global_dbuf_store = dbuf_store;
712
713 /* Status PDU cache */
714 iscsit_status_pdu_cache = kmem_cache_create("iscsit_status_pdu_cache",
715 sizeof (idm_pdu_t) + sizeof (iscsi_scsi_rsp_hdr_t), 8,
716 &iscsit_status_pdu_constructor,
717 NULL, NULL, NULL, NULL, KM_SLEEP);
718
719 /* Default TPG and portal */
720 iscsit_global.global_default_tpg = iscsit_tpg_createdefault();
721 if (iscsit_global.global_default_tpg == NULL) {
722 retval = IDM_STATUS_FAIL;
723 goto tear_down_and_return;
724 }
725
726 /* initialize isns client */
727 (void) iscsit_isns_init(hostinfo);
728 did_iscsit_isns_init = B_TRUE;
729
730 /* Register port provider */
731 pp = stmf_alloc(STMF_STRUCT_PORT_PROVIDER, 0, 0);
732 if (pp == NULL) {
733 retval = IDM_STATUS_FAIL;
734 goto tear_down_and_return;
735 }
736
737 pp->pp_portif_rev = PORTIF_REV_1;
738 pp->pp_instance = 0;
739 pp->pp_name = ISCSIT_MODNAME;
740 pp->pp_cb = iscsit_pp_cb;
741
742 iscsit_global.global_pp = pp;
743
744
745 if (stmf_register_port_provider(pp) != STMF_SUCCESS) {
746 retval = IDM_STATUS_FAIL;
747 goto tear_down_and_return;
748 }
749
750 iscsit_global.global_dispatch_taskq = taskq_create("iscsit_dispatch",
751 1, minclsyspri, 16, 16, TASKQ_PREPOPULATE);
752
753 /* Scan staged PDUs, meaningful in MC/S situations */
754 iscsit_rxpdu_queue_monitor_start();
755
756 return (IDM_STATUS_SUCCESS);
757
758 tear_down_and_return:
759
760 if (iscsit_global.global_dispatch_taskq) {
761 taskq_destroy(iscsit_global.global_dispatch_taskq);
762 iscsit_global.global_dispatch_taskq = NULL;
763 }
764
765 if (did_iscsit_isns_init)
766 iscsit_isns_fini();
767
768 if (iscsit_global.global_default_tpg) {
769 iscsit_tpg_destroydefault(iscsit_global.global_default_tpg);
770 iscsit_global.global_default_tpg = NULL;
771 }
772
773 if (iscsit_global.global_pp)
774 iscsit_global.global_pp = NULL;
775
776 if (pp)
777 stmf_free(pp);
778
779 if (iscsit_status_pdu_cache) {
780 kmem_cache_destroy(iscsit_status_pdu_cache);
781 iscsit_status_pdu_cache = NULL;
782 }
783
784 if (iscsit_global.global_dbuf_store) {
785 stmf_free(iscsit_global.global_dbuf_store);
786 iscsit_global.global_dbuf_store = NULL;
787 }
788
789 if (iscsit_global.global_tsih_pool) {
790 vmem_destroy(iscsit_global.global_tsih_pool);
791 iscsit_global.global_tsih_pool = NULL;
792 }
793
794 avl_destroy(&iscsit_global.global_ini_list);
795 avl_destroy(&iscsit_global.global_tpg_list);
796 list_destroy(&iscsit_global.global_deleted_target_list);
797 avl_destroy(&iscsit_global.global_target_list);
798 avl_destroy(&iscsit_global.global_discovery_sessions);
799
800 idm_refcnt_destroy(&iscsit_global.global_refcnt);
801
802 return (retval);
803 }
804
805 /*
806 * iscsit_disable_svc
807 *
808 * clean up all existing connections and deregister targets from STMF
809 */
810 static void
811 iscsit_disable_svc(void)
812 {
813 iscsit_sess_t *sess;
814
815 ASSERT(iscsit_global.global_svc_state == ISE_DISABLING);
816
817 iscsit_rxpdu_queue_monitor_stop();
818
819 /* tear down discovery sessions */
820 for (sess = avl_first(&iscsit_global.global_discovery_sessions);
821 sess != NULL;
822 sess = AVL_NEXT(&iscsit_global.global_discovery_sessions, sess))
823 iscsit_sess_close(sess);
824
825 /*
826 * Passing NULL to iscsit_config_merge tells it to go to an empty
827 * config.
828 */
829 (void) iscsit_config_merge(NULL);
830
831 /*
832 * Wait until there are no more global references
833 */
834 idm_refcnt_wait_ref(&iscsit_global.global_refcnt);
835 idm_refcnt_destroy(&iscsit_global.global_refcnt);
836
837 /*
838 * Default TPG must be destroyed after global_refcnt is 0.
839 */
840 iscsit_tpg_destroydefault(iscsit_global.global_default_tpg);
841
842 avl_destroy(&iscsit_global.global_discovery_sessions);
843 list_destroy(&iscsit_global.global_deleted_target_list);
844 avl_destroy(&iscsit_global.global_target_list);
845 avl_destroy(&iscsit_global.global_tpg_list);
846 avl_destroy(&iscsit_global.global_ini_list);
847
848 taskq_destroy(iscsit_global.global_dispatch_taskq);
849
850 iscsit_isns_fini();
851
852 stmf_free(iscsit_global.global_dbuf_store);
853 iscsit_global.global_dbuf_store = NULL;
854
855 (void) stmf_deregister_port_provider(iscsit_global.global_pp);
856 stmf_free(iscsit_global.global_pp);
857 iscsit_global.global_pp = NULL;
858
859 kmem_cache_destroy(iscsit_status_pdu_cache);
860 iscsit_status_pdu_cache = NULL;
861
862 vmem_destroy(iscsit_global.global_tsih_pool);
863 iscsit_global.global_tsih_pool = NULL;
864 }
865
866 void
867 iscsit_global_hold()
868 {
869 /*
870 * To take out a global hold, we must either own the global
871 * state mutex or we must be running inside of an ioctl that
872 * has set the global state to ISE_BUSY, ISE_DISABLING, or
873 * ISE_ENABLING. We don't track the "owner" for these flags,
874 * so just checking if they are set is enough for now.
875 */
876 ASSERT((iscsit_global.global_svc_state == ISE_ENABLING) ||
877 (iscsit_global.global_svc_state == ISE_DISABLING) ||
878 (iscsit_global.global_svc_state == ISE_BUSY) ||
879 MUTEX_HELD(&iscsit_global.global_state_mutex));
880
881 idm_refcnt_hold(&iscsit_global.global_refcnt);
882 }
883
884 void
885 iscsit_global_rele()
886 {
887 idm_refcnt_rele(&iscsit_global.global_refcnt);
888 }
889
890 void
891 iscsit_global_wait_ref()
892 {
893 idm_refcnt_wait_ref(&iscsit_global.global_refcnt);
894 }
895
896 /*
897 * IDM callbacks
898 */
899
900 /*ARGSUSED*/
901 void
902 iscsit_rx_pdu(idm_conn_t *ic, idm_pdu_t *rx_pdu)
903 {
904 iscsit_conn_t *ict = ic->ic_handle;
905 switch (IDM_PDU_OPCODE(rx_pdu)) {
906 case ISCSI_OP_SCSI_CMD:
907 ASSERT(0); /* Shouldn't happen */
908 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
909 break;
910 case ISCSI_OP_SNACK_CMD:
911 /*
912 * We'll need to handle this when we support ERL1/2. For
913 * now we treat it as a protocol error.
914 */
915 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
916 idm_conn_event(ic, CE_TRANSPORT_FAIL, 0);
917 break;
918 case ISCSI_OP_SCSI_TASK_MGT_MSG:
919 if (iscsit_check_cmdsn_and_queue(rx_pdu)) {
920 iscsit_set_cmdsn(ict, rx_pdu);
921 iscsit_op_scsi_task_mgmt(ict, rx_pdu);
922 }
923 break;
924 case ISCSI_OP_NOOP_OUT:
925 case ISCSI_OP_LOGIN_CMD:
926 case ISCSI_OP_TEXT_CMD:
927 case ISCSI_OP_LOGOUT_CMD:
928 /*
929 * If/when we switch to userland processing these PDU's
930 * will be handled by iscsitd.
931 */
932 iscsit_deferred_dispatch(rx_pdu);
933 break;
934 default:
935 /* Protocol error */
936 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
937 idm_conn_event(ic, CE_TRANSPORT_FAIL, 0);
938 break;
939 }
940 }
941
942 /*ARGSUSED*/
943 void
944 iscsit_rx_pdu_error(idm_conn_t *ic, idm_pdu_t *rx_pdu, idm_status_t status)
945 {
946 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
947 }
948
949 /*
950 * iscsit_rx_scsi_rsp -- cause the connection to be closed if response rx'd
951 *
952 * A target sends an SCSI Response PDU, it should never receive one.
953 * This has been seen when running the Codemonicon suite of tests which
954 * does negative testing of the protocol. If such a condition occurs using
955 * a normal initiator it most likely means there's data corruption in the
956 * header and that's grounds for dropping the connection as well.
957 */
958 void
959 iscsit_rx_scsi_rsp(idm_conn_t *ic, idm_pdu_t *rx_pdu)
960 {
961 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
962 idm_conn_event(ic, CE_TRANSPORT_FAIL, 0);
963 }
964
965 void
966 iscsit_task_aborted(idm_task_t *idt, idm_status_t status)
967 {
968 iscsit_task_t *itask = idt->idt_private;
969
970 switch (status) {
971 case IDM_STATUS_SUSPENDED:
972 break;
973 case IDM_STATUS_ABORTED:
974 mutex_enter(&itask->it_mutex);
975 itask->it_aborted = B_TRUE;
976 /*
977 * We rely on the fact that STMF tracks outstanding
978 * buffer transfers and will free all of our buffers
979 * before freeing the task so we don't need to
980 * explicitly free the buffers from iscsit/idm
981 */
982 if (itask->it_stmf_abort) {
983 mutex_exit(&itask->it_mutex);
984 /*
985 * Task is no longer active
986 */
987 iscsit_task_done(itask);
988
989 /*
990 * STMF has already asked for this task to be aborted
991 *
992 * STMF specification is wrong... says to return
993 * STMF_ABORTED, the code actually looks for
994 * STMF_ABORT_SUCCESS.
995 */
996 stmf_task_lport_aborted_unlocked(itask->it_stmf_task,
997 STMF_ABORT_SUCCESS, STMF_IOF_LPORT_DONE);
998 return;
999 } else {
1000 mutex_exit(&itask->it_mutex);
1001 /*
1002 * Tell STMF to stop processing the task.
1003 */
1004 stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task,
1005 STMF_ABORTED, NULL);
1006 return;
1007 }
1008 /*NOTREACHED*/
1009 default:
1010 ASSERT(0);
1011 }
1012 }
1013
1014 /*ARGSUSED*/
1015 idm_status_t
1016 iscsit_client_notify(idm_conn_t *ic, idm_client_notify_t icn,
1017 uintptr_t data)
1018 {
1019 idm_status_t rc = IDM_STATUS_SUCCESS;
1020
1021 /*
1022 * IDM client notifications will never occur at interrupt level
1023 * since they are generated from the connection state machine which
1024 * running on taskq threads.
1025 *
1026 */
1027 switch (icn) {
1028 case CN_CONNECT_ACCEPT:
1029 rc = iscsit_conn_accept(ic); /* No data */
1030 break;
1031 case CN_FFP_ENABLED:
1032 rc = iscsit_ffp_enabled(ic); /* No data */
1033 break;
1034 case CN_FFP_DISABLED:
1035 /*
1036 * Data indicates whether this was the result of an
1037 * explicit logout request.
1038 */
1039 rc = iscsit_ffp_disabled(ic, (idm_ffp_disable_t)data);
1040 break;
1041 case CN_CONNECT_LOST:
1042 rc = iscsit_conn_lost(ic);
1043 break;
1044 case CN_CONNECT_DESTROY:
1045 rc = iscsit_conn_destroy(ic);
1046 break;
1047 case CN_LOGIN_FAIL:
1048 /*
1049 * Force the login state machine to completion
1050 */
1051 rc = iscsit_login_fail(ic);
1052 break;
1053 default:
1054 rc = IDM_STATUS_REJECT;
1055 break;
1056 }
1057
1058 return (rc);
1059 }
1060
1061 /*
1062 * iscsit_update_statsn is invoked for all the PDUs which have the StatSN
1063 * field in the header. The StatSN is incremented if the IDM_PDU_ADVANCE_STATSN
1064 * flag is set in the pdu flags field. The StatSN is connection-wide and is
1065 * protected by the mutex ict_statsn_mutex. For Data-In PDUs, if the flag
1066 * IDM_TASK_PHASECOLLAPSE_REQ is set, the status (phase-collapse) is also filled
1067 */
1068 void
1069 iscsit_update_statsn(idm_task_t *idm_task, idm_pdu_t *pdu)
1070 {
1071 iscsi_scsi_rsp_hdr_t *rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
1072 iscsit_conn_t *ict = (iscsit_conn_t *)pdu->isp_ic->ic_handle;
1073 iscsit_task_t *itask = NULL;
1074 scsi_task_t *task = NULL;
1075
1076 mutex_enter(&ict->ict_statsn_mutex);
1077 rsp->statsn = htonl(ict->ict_statsn);
1078 if (pdu->isp_flags & IDM_PDU_ADVANCE_STATSN)
1079 ict->ict_statsn++;
1080 mutex_exit(&ict->ict_statsn_mutex);
1081
1082 /*
1083 * The last SCSI Data PDU passed for a command may also contain the
1084 * status if the status indicates termination with no expections, i.e.
1085 * no sense data or response involved. If the command completes with
1086 * an error, then the response and sense data will be sent in a
1087 * separate iSCSI Response PDU.
1088 */
1089 if ((idm_task) && (idm_task->idt_flags & IDM_TASK_PHASECOLLAPSE_REQ)) {
1090 itask = idm_task->idt_private;
1091 task = itask->it_stmf_task;
1092
1093 rsp->cmd_status = task->task_scsi_status;
1094 rsp->flags |= ISCSI_FLAG_DATA_STATUS;
1095 if (task->task_status_ctrl & TASK_SCTRL_OVER) {
1096 rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW;
1097 } else if (task->task_status_ctrl & TASK_SCTRL_UNDER) {
1098 rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW;
1099 }
1100 rsp->residual_count = htonl(task->task_resid);
1101
1102 /*
1103 * Removing the task from the session task list
1104 * just before the status is sent in the last
1105 * Data PDU transfer
1106 */
1107 iscsit_task_done(itask);
1108 }
1109 }
1110
1111 void
1112 iscsit_build_hdr(idm_task_t *idm_task, idm_pdu_t *pdu, uint8_t opcode)
1113 {
1114 iscsit_task_t *itask = idm_task->idt_private;
1115 iscsi_data_rsp_hdr_t *dh = (iscsi_data_rsp_hdr_t *)pdu->isp_hdr;
1116
1117 /*
1118 * We acquired iscsit_sess_t.ist_sn_mutex in iscsit_xfer_scsi_data
1119 */
1120 ASSERT(MUTEX_HELD(&itask->it_ict->ict_sess->ist_sn_mutex));
1121 /*
1122 * On incoming data, the target transfer tag and Lun is only
1123 * provided by the target if the A bit is set, Since the target
1124 * does not currently support Error Recovery Level 1, the A
1125 * bit is never set.
1126 */
1127 dh->opcode = opcode;
1128 dh->itt = itask->it_itt;
1129 dh->ttt = ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_SCSI_DATA_RSP) ?
1130 ISCSI_RSVD_TASK_TAG : itask->it_ttt;
1131
1132 dh->expcmdsn = htonl(itask->it_ict->ict_sess->ist_expcmdsn);
1133 dh->maxcmdsn = htonl(itask->it_ict->ict_sess->ist_maxcmdsn);
1134
1135 /*
1136 * IDM must set:
1137 *
1138 * data.flags and rtt.flags
1139 * data.dlength
1140 * data.datasn
1141 * data.offset
1142 * statsn, residual_count and cmd_status (for phase collapse)
1143 * rtt.rttsn
1144 * rtt.data_offset
1145 * rtt.data_length
1146 */
1147 }
1148
1149 void
1150 iscsit_keepalive(idm_conn_t *ic)
1151 {
1152 idm_pdu_t *nop_in_pdu;
1153 iscsi_nop_in_hdr_t *nop_in;
1154 iscsit_conn_t *ict = ic->ic_handle;
1155
1156 /*
1157 * IDM noticed the connection has been idle for too long so it's
1158 * time to provoke some activity. Build and transmit an iSCSI
1159 * nop-in PDU -- when the initiator responds it will be counted
1160 * as "activity" and keep the connection alive.
1161 *
1162 * We don't actually care about the response here at the iscsit level
1163 * so we will just throw it away without looking at it when it arrives.
1164 */
1165 nop_in_pdu = idm_pdu_alloc(sizeof (*nop_in), 0);
1166 idm_pdu_init(nop_in_pdu, ic, NULL, NULL);
1167 nop_in = (iscsi_nop_in_hdr_t *)nop_in_pdu->isp_hdr;
1168 bzero(nop_in, sizeof (*nop_in));
1169 nop_in->opcode = ISCSI_OP_NOOP_IN;
1170 nop_in->flags = ISCSI_FLAG_FINAL;
1171 nop_in->itt = ISCSI_RSVD_TASK_TAG;
1172 /*
1173 * When the target sends a NOP-In as a Ping, the target transfer tag
1174 * is set to a valid (not reserved) value and the initiator task tag
1175 * is set to ISCSI_RSVD_TASK_TAG (0xffffffff). In this case the StatSN
1176 * will always contain the next sequence number but the StatSN for the
1177 * connection is not advanced after this PDU is sent.
1178 */
1179 nop_in_pdu->isp_flags |= IDM_PDU_SET_STATSN;
1180 /*
1181 * This works because we don't currently allocate ttt's anywhere else
1182 * in iscsit so as long as we stay out of IDM's range we are safe.
1183 * If we need to allocate ttt's for other PDU's in the future this will
1184 * need to be improved.
1185 */
1186 mutex_enter(&ict->ict_mutex);
1187 nop_in->ttt = ict->ict_keepalive_ttt;
1188 ict->ict_keepalive_ttt++;
1189 if (ict->ict_keepalive_ttt == ISCSI_RSVD_TASK_TAG)
1190 ict->ict_keepalive_ttt = IDM_TASKIDS_MAX;
1191 mutex_exit(&ict->ict_mutex);
1192
1193 iscsit_pdu_tx(nop_in_pdu);
1194 }
1195
1196 static idm_status_t
1197 iscsit_conn_accept(idm_conn_t *ic)
1198 {
1199 iscsit_conn_t *ict;
1200
1201 /*
1202 * We need to get a global hold here to ensure that the service
1203 * doesn't get shutdown prior to establishing a session. This
1204 * gets released in iscsit_conn_destroy().
1205 */
1206 mutex_enter(&iscsit_global.global_state_mutex);
1207 if (iscsit_global.global_svc_state != ISE_ENABLED) {
1208 mutex_exit(&iscsit_global.global_state_mutex);
1209 return (IDM_STATUS_FAIL);
1210 }
1211 iscsit_global_hold();
1212 mutex_exit(&iscsit_global.global_state_mutex);
1213
1214 /*
1215 * Allocate an associated iscsit structure to represent this
1216 * connection. We shouldn't really create a session until we
1217 * get the first login PDU.
1218 */
1219 ict = kmem_zalloc(sizeof (*ict), KM_SLEEP);
1220
1221 ict->ict_ic = ic;
1222 ict->ict_statsn = 1;
1223 ict->ict_keepalive_ttt = IDM_TASKIDS_MAX; /* Avoid IDM TT range */
1224 ic->ic_handle = ict;
1225 mutex_init(&ict->ict_mutex, NULL, MUTEX_DRIVER, NULL);
1226 mutex_init(&ict->ict_statsn_mutex, NULL, MUTEX_DRIVER, NULL);
1227 idm_refcnt_init(&ict->ict_refcnt, ict);
1228 idm_refcnt_init(&ict->ict_dispatch_refcnt, ict);
1229
1230 /*
1231 * Initialize login state machine
1232 */
1233 if (iscsit_login_sm_init(ict) != IDM_STATUS_SUCCESS) {
1234 iscsit_global_rele();
1235 /*
1236 * Cleanup the ict after idm notifies us about this failure
1237 */
1238 return (IDM_STATUS_FAIL);
1239 }
1240
1241 return (IDM_STATUS_SUCCESS);
1242 }
1243
1244 idm_status_t
1245 iscsit_conn_reinstate(iscsit_conn_t *reinstate_ict, iscsit_conn_t *new_ict)
1246 {
1247 idm_status_t result;
1248
1249 /*
1250 * Note in new connection state that this connection is
1251 * reinstating an existing connection.
1252 */
1253 new_ict->ict_reinstating = B_TRUE;
1254 new_ict->ict_reinstate_conn = reinstate_ict;
1255 new_ict->ict_statsn = reinstate_ict->ict_statsn;
1256
1257 /*
1258 * Now generate connection state machine event to existing connection
1259 * so that it starts the cleanup process.
1260 */
1261 result = idm_conn_reinstate_event(reinstate_ict->ict_ic,
1262 new_ict->ict_ic);
1263
1264 return (result);
1265 }
1266
1267 void
1268 iscsit_conn_hold(iscsit_conn_t *ict)
1269 {
1270 idm_refcnt_hold(&ict->ict_refcnt);
1271 }
1272
1273 void
1274 iscsit_conn_rele(iscsit_conn_t *ict)
1275 {
1276 idm_refcnt_rele(&ict->ict_refcnt);
1277 }
1278
1279 void
1280 iscsit_conn_dispatch_hold(iscsit_conn_t *ict)
1281 {
1282 idm_refcnt_hold(&ict->ict_dispatch_refcnt);
1283 }
1284
1285 void
1286 iscsit_conn_dispatch_rele(iscsit_conn_t *ict)
1287 {
1288 idm_refcnt_rele(&ict->ict_dispatch_refcnt);
1289 }
1290
1291 static idm_status_t
1292 iscsit_login_fail(idm_conn_t *ic)
1293 {
1294 iscsit_conn_t *ict = ic->ic_handle;
1295
1296 /* Generate login state machine event */
1297 iscsit_login_sm_event(ict, ILE_LOGIN_CONN_ERROR, NULL);
1298
1299 return (IDM_STATUS_SUCCESS);
1300 }
1301
1302 static idm_status_t
1303 iscsit_ffp_enabled(idm_conn_t *ic)
1304 {
1305 iscsit_conn_t *ict = ic->ic_handle;
1306
1307 /* Generate session state machine event */
1308 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_LOGGED_IN, ict);
1309
1310 return (IDM_STATUS_SUCCESS);
1311 }
1312
1313 static idm_status_t
1314 iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class)
1315 {
1316 iscsit_conn_t *ict = ic->ic_handle;
1317
1318 /* Generate session state machine event */
1319 switch (disable_class) {
1320 case FD_CONN_FAIL:
1321 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_FAIL, ict);
1322 break;
1323 case FD_CONN_LOGOUT:
1324 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_DISABLE, ict);
1325 break;
1326 case FD_SESS_LOGOUT:
1327 iscsit_sess_sm_event(ict->ict_sess, SE_SESSION_CLOSE, ict);
1328 break;
1329 default:
1330 ASSERT(0);
1331 }
1332
1333 return (IDM_STATUS_SUCCESS);
1334 }
1335
1336 static idm_status_t
1337 iscsit_conn_lost(idm_conn_t *ic)
1338 {
1339 iscsit_conn_t *ict = ic->ic_handle;
1340 iscsit_sess_t *ist = ict->ict_sess;
1341 iscsit_cbuf_t *cbuf;
1342 idm_pdu_t *rx_pdu;
1343 int i;
1344
1345 mutex_enter(&ict->ict_mutex);
1346 ict->ict_lost = B_TRUE;
1347 mutex_exit(&ict->ict_mutex);
1348 /*
1349 * scrub the staging queue for all PDUs on this connection
1350 */
1351 if (ist != NULL) {
1352 mutex_enter(&ist->ist_sn_mutex);
1353 for (cbuf = ist->ist_rxpdu_queue, i = 0;
1354 ((cbuf->cb_num_elems > 0) && (i < ISCSIT_RXPDU_QUEUE_LEN));
1355 i++) {
1356 if (((rx_pdu = cbuf->cb_buffer[i]) != NULL) &&
1357 (rx_pdu->isp_ic == ic)) {
1358 /* conn is lost, drop the pdu */
1359 DTRACE_PROBE3(scrubbing__staging__queue,
1360 iscsit_sess_t *, ist, idm_conn_t *, ic,
1361 idm_pdu_t *, rx_pdu);
1362 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
1363 cbuf->cb_buffer[i] = NULL;
1364 cbuf->cb_num_elems--;
1365 iscsit_conn_dispatch_rele(ict);
1366 }
1367 }
1368 mutex_exit(&ist->ist_sn_mutex);
1369 }
1370 /*
1371 * Make sure there aren't any PDU's transitioning from the receive
1372 * handler to the dispatch taskq.
1373 */
1374 if (idm_refcnt_is_held(&ict->ict_dispatch_refcnt) < 0) {
1375 cmn_err(CE_WARN, "Possible hang in iscsit_conn_lost");
1376 }
1377 idm_refcnt_wait_ref(&ict->ict_dispatch_refcnt);
1378
1379 return (IDM_STATUS_SUCCESS);
1380 }
1381
1382 static idm_status_t
1383 iscsit_conn_destroy(idm_conn_t *ic)
1384 {
1385 iscsit_conn_t *ict = ic->ic_handle;
1386
1387 mutex_enter(&ict->ict_mutex);
1388 ict->ict_destroyed = B_TRUE;
1389 mutex_exit(&ict->ict_mutex);
1390
1391 /* Generate session state machine event */
1392 if (ict->ict_sess != NULL) {
1393 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FAIL, ict);
1394 }
1395
1396 idm_refcnt_wait_ref(&ict->ict_dispatch_refcnt);
1397 idm_refcnt_wait_ref(&ict->ict_refcnt);
1398 /*
1399 * The session state machine does not need to post
1400 * events to IDM any longer, so it is safe to set
1401 * the idm connection reference to NULL
1402 */
1403 ict->ict_ic = NULL;
1404
1405 /* Reap the login state machine */
1406 iscsit_login_sm_fini(ict);
1407
1408 /* Clean up any text command remnants */
1409 iscsit_text_cmd_fini(ict);
1410
1411 mutex_destroy(&ict->ict_mutex);
1412 idm_refcnt_destroy(&ict->ict_dispatch_refcnt);
1413 idm_refcnt_destroy(&ict->ict_refcnt);
1414 kmem_free(ict, sizeof (*ict));
1415
1416 iscsit_global_rele();
1417
1418 return (IDM_STATUS_SUCCESS);
1419 }
1420
1421 void
1422 iscsit_conn_logout(iscsit_conn_t *ict)
1423 {
1424 /*
1425 * If the iscsi connection is active, then
1426 * logout the IDM connection by sending a
1427 * CE_LOGOUT_SESSION_SUCCESS, else, no action
1428 * needs to be taken because the connection
1429 * is already in the teardown process.
1430 */
1431 mutex_enter(&ict->ict_mutex);
1432 if (ict->ict_lost == B_FALSE && ict->ict_destroyed == B_FALSE) {
1433 idm_conn_event(ict->ict_ic, CE_LOGOUT_SESSION_SUCCESS, 0);
1434 }
1435 mutex_exit(&ict->ict_mutex);
1436 }
1437
1438 /*
1439 * STMF-related functions
1440 *
1441 * iSCSI to STMF mapping
1442 *
1443 * Session == ?
1444 * Connection == bound to local port but not itself a local port
1445 * Target
1446 * Target portal (group?) == local port (really but we're not going to do this)
1447 * iscsit needs to map connections to local ports (whatever we decide
1448 * they are)
1449 * Target == ?
1450 */
1451
1452 /*ARGSUSED*/
1453 static stmf_data_buf_t *
1454 iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize,
1455 uint32_t flags)
1456 {
1457 iscsit_task_t *itask = task->task_port_private;
1458 idm_buf_t *idm_buffer;
1459 iscsit_buf_t *ibuf;
1460 stmf_data_buf_t *result;
1461 uint32_t bsize;
1462
1463 /*
1464 * If the requested size is larger than MaxBurstLength and the
1465 * given pminsize is also larger than MaxBurstLength, then the
1466 * allocation fails (dbuf = NULL) and pminsize is modified to
1467 * be equal to MaxBurstLength. stmf/sbd then should re-invoke
1468 * this function with the corrected values for transfer.
1469 */
1470 ASSERT(pminsize);
1471 if (size <= itask->it_ict->ict_op.op_max_burst_length) {
1472 bsize = size;
1473 } else if (*pminsize <= itask->it_ict->ict_op.op_max_burst_length) {
1474 bsize = itask->it_ict->ict_op.op_max_burst_length;
1475 } else {
1476 *pminsize = itask->it_ict->ict_op.op_max_burst_length;
1477 return (NULL);
1478 }
1479
1480 /* Alloc buffer */
1481 idm_buffer = idm_buf_alloc(itask->it_ict->ict_ic, NULL, bsize);
1482 if (idm_buffer != NULL) {
1483 result = stmf_alloc(STMF_STRUCT_DATA_BUF,
1484 sizeof (iscsit_buf_t), 0);
1485 if (result != NULL) {
1486 /* Fill in stmf_data_buf_t */
1487 ibuf = result->db_port_private;
1488 ibuf->ibuf_idm_buf = idm_buffer;
1489 ibuf->ibuf_stmf_buf = result;
1490 ibuf->ibuf_is_immed = B_FALSE;
1491 result->db_flags = DB_DONT_CACHE;
1492 result->db_buf_size = bsize;
1493 result->db_data_size = bsize;
1494 result->db_sglist_length = 1;
1495 result->db_sglist[0].seg_addr = idm_buffer->idb_buf;
1496 result->db_sglist[0].seg_length =
1497 idm_buffer->idb_buflen;
1498 return (result);
1499 }
1500
1501 /* Couldn't get the stmf_data_buf_t so free the buffer */
1502 idm_buf_free(idm_buffer);
1503 }
1504
1505 return (NULL);
1506 }
1507
1508 /*ARGSUSED*/
1509 static void
1510 iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf)
1511 {
1512 iscsit_buf_t *ibuf = dbuf->db_port_private;
1513
1514 if (ibuf->ibuf_is_immed) {
1515 /*
1516 * The iscsit_buf_t structure itself will be freed with its
1517 * associated task. Here we just need to free the PDU that
1518 * held the immediate data.
1519 */
1520 idm_pdu_complete(ibuf->ibuf_immed_data_pdu, IDM_STATUS_SUCCESS);
1521 ibuf->ibuf_immed_data_pdu = 0;
1522 } else {
1523 idm_buf_free(ibuf->ibuf_idm_buf);
1524 stmf_free(dbuf);
1525 }
1526 }
1527
1528 /*ARGSUSED*/
1529 stmf_status_t
1530 iscsit_xfer_scsi_data(scsi_task_t *task, stmf_data_buf_t *dbuf,
1531 uint32_t ioflags)
1532 {
1533 iscsit_task_t *iscsit_task = task->task_port_private;
1534 iscsit_sess_t *ict_sess = iscsit_task->it_ict->ict_sess;
1535 iscsit_buf_t *ibuf = dbuf->db_port_private;
1536 int idm_rc;
1537
1538 /*
1539 * If we are aborting then we can ignore this request
1540 */
1541 if (iscsit_task->it_stmf_abort) {
1542 return (STMF_SUCCESS);
1543 }
1544
1545 /*
1546 * If it's not immediate data then start the transfer
1547 */
1548 if (dbuf->db_flags & DB_DIRECTION_TO_RPORT) {
1549 if (ibuf->ibuf_is_immed)
1550 return (iscsit_idm_to_stmf(IDM_STATUS_SUCCESS));
1551 /*
1552 * The DB_SEND_STATUS_GOOD flag in the STMF data buffer allows
1553 * the port provider to phase-collapse, i.e. send the status
1554 * along with the final data PDU for the command. The port
1555 * provider passes this request to the transport layer by
1556 * setting a flag IDM_TASK_PHASECOLLAPSE_REQ in the task.
1557 */
1558 if (dbuf->db_flags & DB_SEND_STATUS_GOOD)
1559 iscsit_task->it_idm_task->idt_flags |=
1560 IDM_TASK_PHASECOLLAPSE_REQ;
1561 /*
1562 * IDM will call iscsit_build_hdr so lock now to serialize
1563 * access to the SN values. We need to lock here to enforce
1564 * lock ordering
1565 */
1566 mutex_enter(&ict_sess->ist_sn_mutex);
1567 idm_rc = idm_buf_tx_to_ini(iscsit_task->it_idm_task,
1568 ibuf->ibuf_idm_buf, dbuf->db_relative_offset,
1569 dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf);
1570 mutex_exit(&ict_sess->ist_sn_mutex);
1571
1572 return (iscsit_idm_to_stmf(idm_rc));
1573 } else if (dbuf->db_flags & DB_DIRECTION_FROM_RPORT) {
1574 ASSERT(ibuf->ibuf_is_immed == B_FALSE);
1575 /* Grab the SN lock (see comment above) */
1576 mutex_enter(&ict_sess->ist_sn_mutex);
1577 idm_rc = idm_buf_rx_from_ini(iscsit_task->it_idm_task,
1578 ibuf->ibuf_idm_buf, dbuf->db_relative_offset,
1579 dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf);
1580 mutex_exit(&ict_sess->ist_sn_mutex);
1581
1582 return (iscsit_idm_to_stmf(idm_rc));
1583 }
1584
1585 /* What are we supposed to do if there is no direction? */
1586 return (STMF_INVALID_ARG);
1587 }
1588
1589 static void
1590 iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status)
1591 {
1592 iscsit_task_t *itask = idb->idb_task_binding->idt_private;
1593 stmf_data_buf_t *dbuf = idb->idb_cb_arg;
1594
1595 dbuf->db_xfer_status = iscsit_idm_to_stmf(status);
1596
1597 /*
1598 * If the task has been aborted then we don't need to call STMF
1599 */
1600 if (itask->it_stmf_abort) {
1601 return;
1602 }
1603
1604 /*
1605 * For ISCSI over TCP (not iSER), the last SCSI Data PDU passed
1606 * for a successful command contains the status as requested by
1607 * by COMSTAR (via the DB_SEND_STATUS_GOOD flag). But the iSER
1608 * transport does not support phase-collapse. So pretend we are
1609 * COMSTAR and send the status in a separate PDU now.
1610 */
1611 if (idb->idb_task_binding->idt_flags & IDM_TASK_PHASECOLLAPSE_SUCCESS) {
1612 /*
1613 * Mark task complete and notify COMSTAR
1614 * that the status has been sent.
1615 */
1616 itask->it_idm_task->idt_state = TASK_COMPLETE;
1617 stmf_send_status_done(itask->it_stmf_task,
1618 iscsit_idm_to_stmf(status), STMF_IOF_LPORT_DONE);
1619 } else if ((dbuf->db_flags & DB_SEND_STATUS_GOOD) &&
1620 status == IDM_STATUS_SUCCESS) {
1621
1622 /*
1623 * The iscsi target port provider - for iSER, emulates the
1624 * DB_SEND_STATUS_GOOD optimization if requested by STMF;
1625 * it sends the status in a separate PDU after the data
1626 * transfer. In this case the port provider should first
1627 * call stmf_data_xfer_done() to mark the transfer complete
1628 * and then send the status. Although STMF will free the
1629 * buffer at the time the task is freed, even if the transfer
1630 * is not marked complete, this behavior makes statistics
1631 * gathering and task state tracking more difficult than it
1632 * needs to be.
1633 */
1634 stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0);
1635 if (iscsit_send_scsi_status(itask->it_stmf_task, 0)
1636 != STMF_SUCCESS) {
1637 stmf_send_status_done(itask->it_stmf_task,
1638 STMF_FAILURE, STMF_IOF_LPORT_DONE);
1639 }
1640 } else {
1641 stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0);
1642 /* don't touch dbuf after stmf_data_xfer_done */
1643 }
1644 }
1645
1646
1647 /*ARGSUSED*/
1648 stmf_status_t
1649 iscsit_send_scsi_status(scsi_task_t *task, uint32_t ioflags)
1650 {
1651 iscsit_task_t *itask = task->task_port_private;
1652 iscsi_scsi_rsp_hdr_t *rsp;
1653 idm_pdu_t *pdu;
1654 int resp_datalen;
1655
1656 /*
1657 * If this task is aborted then we don't need to respond.
1658 */
1659 if (itask->it_stmf_abort) {
1660 return (STMF_SUCCESS);
1661 }
1662
1663 /*
1664 * If this is a task management status, handle it elsewhere.
1665 */
1666 if (task->task_mgmt_function != TM_NONE) {
1667 /*
1668 * Don't wait for the PDU completion to tell STMF
1669 * the task is done -- it doesn't really matter and
1670 * it makes life complicated if STMF later asks us to
1671 * abort the request and we don't know whether the
1672 * status has been sent or not.
1673 */
1674 itask->it_tm_responded = B_TRUE;
1675 iscsit_send_task_mgmt_resp(itask->it_tm_pdu,
1676 (task->task_completion_status == STMF_SUCCESS) ?
1677 SCSI_TCP_TM_RESP_COMPLETE : SCSI_TCP_TM_RESP_FUNC_NOT_SUPP);
1678 stmf_send_status_done(task, STMF_SUCCESS,
1679 STMF_IOF_LPORT_DONE);
1680 return (STMF_SUCCESS);
1681 }
1682
1683 /*
1684 * Remove the task from the session task list
1685 */
1686 iscsit_task_done(itask);
1687
1688 /*
1689 * Send status
1690 */
1691 mutex_enter(&itask->it_idm_task->idt_mutex);
1692 if ((itask->it_idm_task->idt_state == TASK_ACTIVE) &&
1693 (task->task_completion_status == STMF_SUCCESS) &&
1694 (task->task_sense_length == 0) &&
1695 (task->task_resid == 0)) {
1696 itask->it_idm_task->idt_state = TASK_COMPLETE;
1697 /* PDU callback releases task hold */
1698 idm_task_hold(itask->it_idm_task);
1699 mutex_exit(&itask->it_idm_task->idt_mutex);
1700 /*
1701 * Fast path. Cached status PDU's are already
1702 * initialized. We just need to fill in
1703 * connection and task information. StatSN is
1704 * incremented by 1 for every status sent a
1705 * connection.
1706 */
1707 pdu = kmem_cache_alloc(iscsit_status_pdu_cache, KM_SLEEP);
1708 pdu->isp_ic = itask->it_ict->ict_ic;
1709 pdu->isp_private = itask;
1710 pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
1711
1712 rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
1713 rsp->itt = itask->it_itt;
1714 /*
1715 * ExpDataSN is the number of R2T and Data-In (read)
1716 * PDUs the target has sent for the SCSI command.
1717 *
1718 * Since there is no support for bidirectional transfer
1719 * yet, either idt_exp_datasn or idt_exp_rttsn, but not
1720 * both is valid at any time
1721 */
1722 rsp->expdatasn = (itask->it_idm_task->idt_exp_datasn != 0) ?
1723 htonl(itask->it_idm_task->idt_exp_datasn):
1724 htonl(itask->it_idm_task->idt_exp_rttsn);
1725 rsp->cmd_status = task->task_scsi_status;
1726 iscsit_pdu_tx(pdu);
1727 return (STMF_SUCCESS);
1728 } else {
1729 if (itask->it_idm_task->idt_state != TASK_ACTIVE) {
1730 mutex_exit(&itask->it_idm_task->idt_mutex);
1731 return (STMF_FAILURE);
1732 }
1733 itask->it_idm_task->idt_state = TASK_COMPLETE;
1734 /* PDU callback releases task hold */
1735 idm_task_hold(itask->it_idm_task);
1736 mutex_exit(&itask->it_idm_task->idt_mutex);
1737
1738 resp_datalen = (task->task_sense_length == 0) ? 0 :
1739 (task->task_sense_length + sizeof (uint16_t));
1740
1741 pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen);
1742 idm_pdu_init(pdu, itask->it_ict->ict_ic, itask,
1743 iscsit_send_status_done);
1744 pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
1745
1746 rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
1747 bzero(rsp, sizeof (*rsp));
1748 rsp->opcode = ISCSI_OP_SCSI_RSP;
1749
1750 rsp->flags = ISCSI_FLAG_FINAL;
1751 if (task->task_status_ctrl & TASK_SCTRL_OVER) {
1752 rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW;
1753 } else if (task->task_status_ctrl & TASK_SCTRL_UNDER) {
1754 rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW;
1755 }
1756
1757 rsp->bi_residual_count = 0;
1758 rsp->residual_count = htonl(task->task_resid);
1759 rsp->itt = itask->it_itt;
1760 rsp->response = ISCSI_STATUS_CMD_COMPLETED;
1761 rsp->expdatasn = (itask->it_idm_task->idt_exp_datasn != 0) ?
1762 htonl(itask->it_idm_task->idt_exp_datasn):
1763 htonl(itask->it_idm_task->idt_exp_rttsn);
1764 rsp->cmd_status = task->task_scsi_status;
1765 if (task->task_sense_length != 0) {
1766 /*
1767 * Add a byte to provide the sense length in
1768 * the response
1769 */
1770 *(uint16_t *)((void *)pdu->isp_data) =
1771 htons(task->task_sense_length);
1772 bcopy(task->task_sense_data,
1773 (uint8_t *)pdu->isp_data +
1774 sizeof (uint16_t),
1775 task->task_sense_length);
1776 hton24(rsp->dlength, resp_datalen);
1777 }
1778
1779 DTRACE_PROBE5(iscsi__scsi__response,
1780 iscsit_conn_t *, itask->it_ict,
1781 uint8_t, rsp->response,
1782 uint8_t, rsp->cmd_status,
1783 idm_pdu_t *, pdu,
1784 scsi_task_t *, task);
1785
1786 iscsit_pdu_tx(pdu);
1787
1788 return (STMF_SUCCESS);
1789 }
1790 }
1791
1792 /*ARGSUSED*/
1793 static void
1794 iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status)
1795 {
1796 iscsit_task_t *itask;
1797 boolean_t aborted;
1798
1799 itask = pdu->isp_private;
1800 aborted = itask->it_stmf_abort;
1801
1802 /*
1803 * After releasing the hold the task may be freed at any time so
1804 * don't touch it.
1805 */
1806 idm_task_rele(itask->it_idm_task);
1807 if (!aborted) {
1808 stmf_send_status_done(itask->it_stmf_task,
1809 iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE);
1810 }
1811 kmem_cache_free(iscsit_status_pdu_cache, pdu);
1812 }
1813
1814 /*ARGSUSED*/
1815 static void
1816 iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status)
1817 {
1818 iscsit_task_t *itask;
1819 boolean_t aborted;
1820
1821 itask = pdu->isp_private;
1822 aborted = itask->it_stmf_abort;
1823
1824 /*
1825 * After releasing the hold the task may be freed at any time so
1826 * don't touch it.
1827 */
1828 idm_task_rele(itask->it_idm_task);
1829 if (!aborted) {
1830 stmf_send_status_done(itask->it_stmf_task,
1831 iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE);
1832 }
1833 idm_pdu_free(pdu);
1834 }
1835
1836
1837 void
1838 iscsit_lport_task_free(scsi_task_t *task)
1839 {
1840 iscsit_task_t *itask = task->task_port_private;
1841
1842 /* We only call idm_task_start for regular tasks, not task management */
1843 if (task->task_mgmt_function == TM_NONE) {
1844 idm_task_done(itask->it_idm_task);
1845 iscsit_task_free(itask);
1846 return;
1847 } else {
1848 iscsit_tm_task_free(itask);
1849 }
1850 }
1851
1852 /*ARGSUSED*/
1853 stmf_status_t
1854 iscsit_abort(stmf_local_port_t *lport, int abort_cmd, void *arg, uint32_t flags)
1855 {
1856 scsi_task_t *st = (scsi_task_t *)arg;
1857 iscsit_task_t *iscsit_task;
1858 idm_task_t *idt;
1859
1860 /*
1861 * If this is a task management request then there's really not much to
1862 * do.
1863 */
1864 if (st->task_mgmt_function != TM_NONE) {
1865 return (STMF_ABORT_SUCCESS);
1866 }
1867
1868 /*
1869 * Regular task, start cleaning up
1870 */
1871 iscsit_task = st->task_port_private;
1872 idt = iscsit_task->it_idm_task;
1873 mutex_enter(&iscsit_task->it_mutex);
1874 iscsit_task->it_stmf_abort = B_TRUE;
1875 if (iscsit_task->it_aborted) {
1876 mutex_exit(&iscsit_task->it_mutex);
1877 /*
1878 * Task is no longer active
1879 */
1880 iscsit_task_done(iscsit_task);
1881
1882 /*
1883 * STMF specification is wrong... says to return
1884 * STMF_ABORTED, the code actually looks for
1885 * STMF_ABORT_SUCCESS.
1886 */
1887 return (STMF_ABORT_SUCCESS);
1888 } else {
1889 mutex_exit(&iscsit_task->it_mutex);
1890 /*
1891 * Call IDM to abort the task. Due to a variety of
1892 * circumstances the task may already be in the process of
1893 * aborting.
1894 */
1895 return (idm_task_abort(idt->idt_ic, idt, AT_TASK_MGMT_ABORT));
1896 }
1897
1898 /*NOTREACHED*/
1899 }
1900
1901 /*ARGSUSED*/
1902 void
1903 iscsit_ctl(stmf_local_port_t *lport, int cmd, void *arg)
1904 {
1905 iscsit_tgt_t *iscsit_tgt;
1906
1907 ASSERT((cmd == STMF_CMD_LPORT_ONLINE) ||
1908 (cmd == STMF_ACK_LPORT_ONLINE_COMPLETE) ||
1909 (cmd == STMF_CMD_LPORT_OFFLINE) ||
1910 (cmd == STMF_ACK_LPORT_OFFLINE_COMPLETE));
1911
1912 iscsit_tgt = (iscsit_tgt_t *)lport->lport_port_private;
1913
1914 switch (cmd) {
1915 case STMF_CMD_LPORT_ONLINE:
1916 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_REQ);
1917 break;
1918 case STMF_CMD_LPORT_OFFLINE:
1919 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_REQ);
1920 break;
1921 case STMF_ACK_LPORT_ONLINE_COMPLETE:
1922 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_COMPLETE_ACK);
1923 break;
1924 case STMF_ACK_LPORT_OFFLINE_COMPLETE:
1925 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_COMPLETE_ACK);
1926 break;
1927
1928 default:
1929 break;
1930 }
1931 }
1932
1933 static stmf_status_t
1934 iscsit_idm_to_stmf(idm_status_t idmrc)
1935 {
1936 switch (idmrc) {
1937 case IDM_STATUS_SUCCESS:
1938 return (STMF_SUCCESS);
1939 default:
1940 return (STMF_FAILURE);
1941 }
1942 /*NOTREACHED*/
1943 }
1944
1945 void
1946 iscsit_op_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu)
1947 {
1948 iscsit_conn_t *ict = ic->ic_handle;
1949
1950 if (iscsit_check_cmdsn_and_queue(rx_pdu)) {
1951 iscsit_post_scsi_cmd(ic, rx_pdu);
1952 }
1953 iscsit_process_pdu_in_queue(ict->ict_sess);
1954 }
1955
1956 static int
1957 iscsit_validate_idm_pdu(idm_pdu_t *rx_pdu)
1958 {
1959 iscsi_scsi_cmd_hdr_t *iscsi_scsi =
1960 (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
1961
1962 if ((iscsi_scsi->scb[0] == SCMD_READ) ||
1963 (iscsi_scsi->scb[0] == SCMD_READ_G1) ||
1964 (iscsi_scsi->scb[0] == SCMD_READ_G4)) {
1965 if (iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE)
1966 return (IDM_STATUS_FAIL);
1967 }
1968 return (IDM_STATUS_SUCCESS);
1969 }
1970
1971 /*
1972 * ISCSI protocol
1973 */
1974
1975 void
1976 iscsit_post_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu)
1977 {
1978 iscsit_conn_t *ict;
1979 iscsit_task_t *itask;
1980 scsi_task_t *task;
1981 iscsit_buf_t *ibuf;
1982 iscsi_scsi_cmd_hdr_t *iscsi_scsi =
1983 (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
1984 iscsi_addl_hdr_t *ahs_hdr;
1985 uint16_t addl_cdb_len = 0;
1986
1987 ict = ic->ic_handle;
1988 if (iscsit_validate_idm_pdu(rx_pdu) != IDM_STATUS_SUCCESS) {
1989 /* Finish processing request */
1990 iscsit_set_cmdsn(ict, rx_pdu);
1991
1992 iscsit_send_direct_scsi_resp(ict, rx_pdu,
1993 ISCSI_STATUS_CMD_COMPLETED, STATUS_CHECK);
1994 idm_pdu_complete(rx_pdu, IDM_STATUS_PROTOCOL_ERROR);
1995 return;
1996 }
1997
1998 itask = iscsit_task_alloc(ict);
1999 if (itask == NULL) {
2000 /* Finish processing request */
2001 iscsit_set_cmdsn(ict, rx_pdu);
2002
2003 iscsit_send_direct_scsi_resp(ict, rx_pdu,
2004 ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY);
2005 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2006 return;
2007 }
2008
2009 /*
2010 * Note CmdSN and ITT in task. IDM will have already validated this
2011 * request against the connection state so we don't need to check
2012 * that (the connection may have changed state in the meantime but
2013 * we will catch that when we try to send a response)
2014 */
2015 itask->it_cmdsn = ntohl(iscsi_scsi->cmdsn);
2016 itask->it_itt = iscsi_scsi->itt;
2017
2018 /*
2019 * Check for extended CDB AHS
2020 */
2021 if (iscsi_scsi->hlength > 0) {
2022 ahs_hdr = (iscsi_addl_hdr_t *)iscsi_scsi;
2023 addl_cdb_len = ((ahs_hdr->ahs_hlen_hi << 8) |
2024 ahs_hdr->ahs_hlen_lo) - 1; /* Adjust for reserved byte */
2025 if (((addl_cdb_len + 4) / sizeof (uint32_t)) >
2026 iscsi_scsi->hlength) {
2027 /* Mangled header info, drop it */
2028 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2029 return;
2030 }
2031 }
2032
2033 ict = rx_pdu->isp_ic->ic_handle; /* IDM client private */
2034
2035 /*
2036 * Add task to session list. This function will also check to
2037 * ensure that the task does not already exist.
2038 */
2039 if (iscsit_task_start(itask) != IDM_STATUS_SUCCESS) {
2040 /*
2041 * Task exists, free all resources and reject. Don't
2042 * update expcmdsn in this case because RFC 3720 says
2043 * "The CmdSN of the rejected command PDU (if it is a
2044 * non-immediate command) MUST NOT be considered received
2045 * by the target (i.e., a command sequence gap must be
2046 * assumed for the CmdSN), even though the CmdSN of the
2047 * rejected command PDU may be reliably ascertained. Upon
2048 * receiving the Reject, the initiator MUST plug the CmdSN
2049 * gap in order to continue to use the session. The gap
2050 * may be plugged either by transmitting a command PDU
2051 * with the same CmdSN, or by aborting the task (see section
2052 * 6.9 on how an abort may plug a CmdSN gap)." (Section 6.3)
2053 */
2054 iscsit_task_free(itask);
2055 iscsit_send_reject(ict, rx_pdu, ISCSI_REJECT_TASK_IN_PROGRESS);
2056 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2057 return;
2058 }
2059
2060 /* Update sequence numbers */
2061 iscsit_set_cmdsn(ict, rx_pdu);
2062
2063 /*
2064 * Allocate STMF task
2065 */
2066 itask->it_stmf_task = stmf_task_alloc(
2067 itask->it_ict->ict_sess->ist_lport,
2068 itask->it_ict->ict_sess->ist_stmf_sess, iscsi_scsi->lun,
2069 16 + addl_cdb_len, 0);
2070 if (itask->it_stmf_task == NULL) {
2071 /*
2072 * Either stmf really couldn't get memory for a task or,
2073 * more likely, the LU is currently in reset. Either way
2074 * we have no choice but to fail the request.
2075 */
2076 iscsit_task_done(itask);
2077 iscsit_task_free(itask);
2078 iscsit_send_direct_scsi_resp(ict, rx_pdu,
2079 ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY);
2080 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2081 return;
2082 }
2083
2084 task = itask->it_stmf_task;
2085 task->task_port_private = itask;
2086
2087 bcopy(iscsi_scsi->lun, task->task_lun_no, sizeof (task->task_lun_no));
2088
2089 /*
2090 * iSCSI and Comstar use the same values. Should we rely on this
2091 * or translate them bit-wise?
2092 */
2093
2094 task->task_flags =
2095 (((iscsi_scsi->flags & ISCSI_FLAG_CMD_READ) ? TF_READ_DATA : 0) |
2096 ((iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ? TF_WRITE_DATA : 0) |
2097 ((rx_pdu->isp_datalen == 0) ? 0 : TF_INITIAL_BURST));
2098
2099 switch (iscsi_scsi->flags & ISCSI_FLAG_CMD_ATTR_MASK) {
2100 case ISCSI_ATTR_UNTAGGED:
2101 break;
2102 case ISCSI_ATTR_SIMPLE:
2103 task->task_additional_flags |= TF_ATTR_SIMPLE_QUEUE;
2104 break;
2105 case ISCSI_ATTR_ORDERED:
2106 task->task_additional_flags |= TF_ATTR_ORDERED_QUEUE;
2107 break;
2108 case ISCSI_ATTR_HEAD_OF_QUEUE:
2109 task->task_additional_flags |= TF_ATTR_HEAD_OF_QUEUE;
2110 break;
2111 case ISCSI_ATTR_ACA:
2112 task->task_additional_flags |= TF_ATTR_ACA;
2113 break;
2114 default:
2115 /* Protocol error but just take it, treat as untagged */
2116 break;
2117 }
2118
2119
2120 task->task_additional_flags = 0;
2121 task->task_priority = 0;
2122 task->task_mgmt_function = TM_NONE;
2123
2124 /*
2125 * This "task_max_nbufs" doesn't map well to BIDI. We probably need
2126 * parameter for each direction. "MaxOutstandingR2T" may very well
2127 * be set to one which could prevent us from doing simultaneous
2128 * transfers in each direction.
2129 */
2130 task->task_max_nbufs = (iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ?
2131 ict->ict_op.op_max_outstanding_r2t : STMF_BUFS_MAX;
2132 task->task_cmd_seq_no = ntohl(iscsi_scsi->itt);
2133 task->task_expected_xfer_length = ntohl(iscsi_scsi->data_length);
2134
2135 /* Copy CDB */
2136 bcopy(iscsi_scsi->scb, task->task_cdb, 16);
2137 if (addl_cdb_len > 0) {
2138 bcopy(ahs_hdr->ahs_extscb, task->task_cdb + 16, addl_cdb_len);
2139 }
2140
2141 DTRACE_ISCSI_3(scsi__command, idm_conn_t *, ic,
2142 iscsi_scsi_cmd_hdr_t *, (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr,
2143 scsi_task_t *, task);
2144
2145 /*
2146 * Copy the transport header into the task handle from the PDU
2147 * handle. The transport header describes this task's remote tagged
2148 * buffer.
2149 */
2150 if (rx_pdu->isp_transport_hdrlen != 0) {
2151 bcopy(rx_pdu->isp_transport_hdr,
2152 itask->it_idm_task->idt_transport_hdr,
2153 rx_pdu->isp_transport_hdrlen);
2154 }
2155
2156 /*
2157 * Tell IDM about our new active task
2158 */
2159 idm_task_start(itask->it_idm_task, (uintptr_t)itask->it_itt);
2160
2161 /*
2162 * If we have any immediate data then setup the immediate buffer
2163 * context that comes with the task
2164 */
2165 if (rx_pdu->isp_datalen) {
2166 ibuf = itask->it_immed_data;
2167 ibuf->ibuf_immed_data_pdu = rx_pdu;
2168 ibuf->ibuf_stmf_buf->db_data_size = rx_pdu->isp_datalen;
2169 ibuf->ibuf_stmf_buf->db_buf_size = rx_pdu->isp_datalen;
2170 ibuf->ibuf_stmf_buf->db_relative_offset = 0;
2171 ibuf->ibuf_stmf_buf->db_sglist[0].seg_length =
2172 rx_pdu->isp_datalen;
2173 ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr = rx_pdu->isp_data;
2174
2175 DTRACE_ISCSI_8(xfer__start, idm_conn_t *, ic,
2176 uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr,
2177 uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset,
2178 uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */
2179 uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI);
2180
2181 /*
2182 * For immediate data transfer, there is no callback from
2183 * stmf to indicate that the initial burst of data is
2184 * transferred successfully. In some cases, the task can
2185 * get freed before execution returns from stmf_post_task.
2186 * Although this xfer-start/done probe accurately tracks
2187 * the size of the transfer, it does only provide a best
2188 * effort on the timing of the transfer.
2189 */
2190 DTRACE_ISCSI_8(xfer__done, idm_conn_t *, ic,
2191 uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr,
2192 uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset,
2193 uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */
2194 uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI);
2195 stmf_post_task(task, ibuf->ibuf_stmf_buf);
2196 } else {
2197
2198 stmf_post_task(task, NULL);
2199 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2200 }
2201 }
2202
2203 void
2204 iscsit_deferred_dispatch(idm_pdu_t *rx_pdu)
2205 {
2206 iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle;
2207
2208 /*
2209 * If this isn't a login packet, we need a session. Otherwise
2210 * this is a protocol error (perhaps one IDM should've caught?).
2211 */
2212 if (IDM_PDU_OPCODE(rx_pdu) != ISCSI_OP_LOGIN_CMD &&
2213 ict->ict_sess == NULL) {
2214 DTRACE_PROBE2(iscsi__idm__deferred__no__session,
2215 iscsit_conn_t *, ict, idm_pdu_t *, rx_pdu);
2216 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
2217 return;
2218 }
2219
2220 /*
2221 * If the connection has been lost then ignore new PDU's
2222 */
2223 mutex_enter(&ict->ict_mutex);
2224 if (ict->ict_lost) {
2225 mutex_exit(&ict->ict_mutex);
2226 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
2227 return;
2228 }
2229
2230 /*
2231 * Grab a hold on the connection to prevent it from going away
2232 * between now and when the taskq function is called.
2233 */
2234 iscsit_conn_dispatch_hold(ict);
2235 mutex_exit(&ict->ict_mutex);
2236
2237 taskq_dispatch_ent(iscsit_global.global_dispatch_taskq,
2238 iscsit_deferred, rx_pdu, 0, &rx_pdu->isp_tqent);
2239 }
2240
2241 static void
2242 iscsit_deferred(void *rx_pdu_void)
2243 {
2244 idm_pdu_t *rx_pdu = rx_pdu_void;
2245 idm_conn_t *ic = rx_pdu->isp_ic;
2246 iscsit_conn_t *ict = ic->ic_handle;
2247
2248 /*
2249 * NOP and Task Management Commands can be marked for immediate
2250 * delivery. Commands marked as 'Immediate' are to be considered
2251 * for execution as soon as they arrive on the target. So these
2252 * should not be checked for sequence order and put in a queue.
2253 * The CmdSN is not advanced for Immediate Commands.
2254 */
2255 switch (IDM_PDU_OPCODE(rx_pdu)) {
2256 case ISCSI_OP_NOOP_OUT:
2257 if (iscsit_check_cmdsn_and_queue(rx_pdu)) {
2258 iscsit_set_cmdsn(ict, rx_pdu);
2259 iscsit_pdu_op_noop(ict, rx_pdu);
2260 }
2261 break;
2262 case ISCSI_OP_LOGIN_CMD:
2263 iscsit_pdu_op_login_cmd(ict, rx_pdu);
2264 iscsit_conn_dispatch_rele(ict);
2265 return;
2266 case ISCSI_OP_TEXT_CMD:
2267 if (iscsit_check_cmdsn_and_queue(rx_pdu)) {
2268 iscsit_set_cmdsn(ict, rx_pdu);
2269 iscsit_pdu_op_text_cmd(ict, rx_pdu);
2270 }
2271 break;
2272 case ISCSI_OP_LOGOUT_CMD:
2273 if (iscsit_check_cmdsn_and_queue(rx_pdu)) {
2274 iscsit_set_cmdsn(ict, rx_pdu);
2275 iscsit_pdu_op_logout_cmd(ict, rx_pdu);
2276 }
2277 break;
2278 default:
2279 /* Protocol error. IDM should have caught this */
2280 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
2281 ASSERT(0);
2282 break;
2283 }
2284 /*
2285 * Check if there are other PDUs in the session staging queue
2286 * waiting to be posted to SCSI layer.
2287 */
2288 iscsit_process_pdu_in_queue(ict->ict_sess);
2289
2290 iscsit_conn_dispatch_rele(ict);
2291 }
2292
2293 static void
2294 iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu,
2295 uint8_t response, uint8_t cmd_status)
2296 {
2297 idm_pdu_t *rsp_pdu;
2298 idm_conn_t *ic;
2299 iscsi_scsi_rsp_hdr_t *resp;
2300 iscsi_scsi_cmd_hdr_t *req =
2301 (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
2302
2303 ic = ict->ict_ic;
2304
2305 rsp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_rsp_hdr_t), 0);
2306 idm_pdu_init(rsp_pdu, ic, NULL, NULL);
2307 /*
2308 * StatSN is incremented by 1 for every response sent on
2309 * a connection except for responses sent as a result of
2310 * a retry or SNACK
2311 */
2312 rsp_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2313
2314 resp = (iscsi_scsi_rsp_hdr_t *)rsp_pdu->isp_hdr;
2315
2316 resp->opcode = ISCSI_OP_SCSI_RSP;
2317 resp->flags = ISCSI_FLAG_FINAL;
2318 resp->response = response;
2319 resp->cmd_status = cmd_status;
2320 resp->itt = req->itt;
2321 if ((response == ISCSI_STATUS_CMD_COMPLETED) &&
2322 (req->data_length != 0) &&
2323 ((req->flags & ISCSI_FLAG_CMD_READ) ||
2324 (req->flags & ISCSI_FLAG_CMD_WRITE))) {
2325 resp->flags |= ISCSI_FLAG_CMD_UNDERFLOW;
2326 resp->residual_count = req->data_length;
2327 }
2328
2329 DTRACE_PROBE4(iscsi__scsi__direct__response,
2330 iscsit_conn_t *, ict,
2331 uint8_t, resp->response,
2332 uint8_t, resp->cmd_status,
2333 idm_pdu_t *, rsp_pdu);
2334
2335 iscsit_pdu_tx(rsp_pdu);
2336 }
2337
2338 void
2339 iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu, uint8_t tm_status)
2340 {
2341 iscsi_scsi_task_mgt_rsp_hdr_t *tm_resp;
2342
2343 /*
2344 * The target must take note of the last-sent StatSN.
2345 * The StatSN is to be incremented after sending a
2346 * task management response. Digest recovery can only
2347 * work if StatSN is incremented.
2348 */
2349 tm_resp_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2350 tm_resp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr;
2351 tm_resp->response = tm_status;
2352
2353 DTRACE_PROBE3(iscsi__scsi__tm__response,
2354 iscsit_conn_t *, tm_resp_pdu->isp_ic->ic_handle,
2355 uint8_t, tm_resp->response,
2356 idm_pdu_t *, tm_resp_pdu);
2357 iscsit_pdu_tx(tm_resp_pdu);
2358 }
2359
2360 void
2361 iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2362 {
2363 idm_pdu_t *tm_resp_pdu;
2364 iscsit_task_t *itask;
2365 iscsit_task_t *tm_itask;
2366 scsi_task_t *task;
2367 iscsi_scsi_task_mgt_hdr_t *iscsi_tm =
2368 (iscsi_scsi_task_mgt_hdr_t *)rx_pdu->isp_hdr;
2369 iscsi_scsi_task_mgt_rsp_hdr_t *iscsi_tm_rsp =
2370 (iscsi_scsi_task_mgt_rsp_hdr_t *)rx_pdu->isp_hdr;
2371 uint32_t rtt, cmdsn, refcmdsn;
2372 uint8_t tm_func;
2373
2374 /*
2375 * Setup response PDU (response field will get filled in later)
2376 */
2377 tm_resp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_task_mgt_rsp_hdr_t), 0);
2378 if (tm_resp_pdu == NULL) {
2379 /* Can't respond, just drop it */
2380 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2381 return;
2382 }
2383 idm_pdu_init(tm_resp_pdu, ict->ict_ic, NULL, NULL);
2384 iscsi_tm_rsp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr;
2385 bzero(iscsi_tm_rsp, sizeof (iscsi_scsi_task_mgt_rsp_hdr_t));
2386 iscsi_tm_rsp->opcode = ISCSI_OP_SCSI_TASK_MGT_RSP;
2387 iscsi_tm_rsp->flags = ISCSI_FLAG_FINAL;
2388 iscsi_tm_rsp->itt = rx_pdu->isp_hdr->itt;
2389
2390 /*
2391 * Figure out what we're being asked to do.
2392 */
2393 DTRACE_PROBE4(iscsi__scsi__tm__request,
2394 iscsit_conn_t *, ict,
2395 uint8_t, (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK),
2396 uint32_t, iscsi_tm->rtt,
2397 idm_pdu_t *, rx_pdu);
2398 switch (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK) {
2399 case ISCSI_TM_FUNC_ABORT_TASK:
2400 /*
2401 * STMF doesn't currently support the "abort task" task
2402 * management command although it does support aborting
2403 * an individual task. We'll get STMF to abort the task
2404 * for us but handle the details of the task management
2405 * command ourselves.
2406 *
2407 * Find the task associated with the referenced task tag.
2408 */
2409 rtt = iscsi_tm->rtt;
2410 itask = (iscsit_task_t *)idm_task_find_by_handle(ict->ict_ic,
2411 (uintptr_t)rtt);
2412
2413 if (itask == NULL) {
2414 cmdsn = ntohl(iscsi_tm->cmdsn);
2415 refcmdsn = ntohl(iscsi_tm->refcmdsn);
2416
2417 /*
2418 * Task was not found. But the SCSI command could be
2419 * on the rxpdu wait queue. If RefCmdSN is within
2420 * the CmdSN window and less than CmdSN of the TM
2421 * function, return "Function Complete". Otherwise,
2422 * return "Task Does Not Exist".
2423 */
2424
2425 if (iscsit_cmdsn_in_window(ict, refcmdsn) &&
2426 iscsit_sna_lt(refcmdsn, cmdsn)) {
2427 mutex_enter(&ict->ict_sess->ist_sn_mutex);
2428 if (iscsit_remove_pdu_from_queue(
2429 ict->ict_sess, refcmdsn)) {
2430 iscsit_conn_dispatch_rele(ict);
2431 }
2432 mutex_exit(&ict->ict_sess->ist_sn_mutex);
2433 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2434 SCSI_TCP_TM_RESP_COMPLETE);
2435 } else {
2436 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2437 SCSI_TCP_TM_RESP_NO_TASK);
2438 }
2439 } else {
2440
2441 /*
2442 * Tell STMF to abort the task. This will do no harm
2443 * if the task is already complete.
2444 */
2445 stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task,
2446 STMF_ABORTED, NULL);
2447
2448 /*
2449 * Make sure the task hasn't already completed
2450 */
2451 mutex_enter(&itask->it_idm_task->idt_mutex);
2452 if ((itask->it_idm_task->idt_state == TASK_COMPLETE) ||
2453 (itask->it_idm_task->idt_state == TASK_IDLE)) {
2454 /*
2455 * Task is complete, return "Task Does Not
2456 * Exist"
2457 */
2458 mutex_exit(&itask->it_idm_task->idt_mutex);
2459 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2460 SCSI_TCP_TM_RESP_NO_TASK);
2461 } else {
2462 /*
2463 * STMF is now aborting the task, return
2464 * "Function Complete"
2465 */
2466 mutex_exit(&itask->it_idm_task->idt_mutex);
2467 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2468 SCSI_TCP_TM_RESP_COMPLETE);
2469 }
2470 idm_task_rele(itask->it_idm_task);
2471 }
2472 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2473 return;
2474
2475 case ISCSI_TM_FUNC_ABORT_TASK_SET:
2476 tm_func = TM_ABORT_TASK_SET;
2477 break;
2478
2479 case ISCSI_TM_FUNC_CLEAR_ACA:
2480 tm_func = TM_CLEAR_ACA;
2481 break;
2482
2483 case ISCSI_TM_FUNC_CLEAR_TASK_SET:
2484 tm_func = TM_CLEAR_TASK_SET;
2485 break;
2486
2487 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
2488 tm_func = TM_LUN_RESET;
2489 break;
2490
2491 case ISCSI_TM_FUNC_TARGET_WARM_RESET:
2492 tm_func = TM_TARGET_WARM_RESET;
2493 break;
2494
2495 case ISCSI_TM_FUNC_TARGET_COLD_RESET:
2496 tm_func = TM_TARGET_COLD_RESET;
2497 break;
2498
2499 case ISCSI_TM_FUNC_TASK_REASSIGN:
2500 /*
2501 * We do not currently support allegiance reassignment. When
2502 * we start supporting ERL1+, we will need to.
2503 */
2504 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2505 SCSI_TCP_TM_RESP_NO_ALLG_REASSN);
2506 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2507 return;
2508
2509 default:
2510 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2511 SCSI_TCP_TM_RESP_REJECTED);
2512 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2513 return;
2514 }
2515
2516 tm_itask = iscsit_tm_task_alloc(ict);
2517 if (tm_itask == NULL) {
2518 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2519 SCSI_TCP_TM_RESP_REJECTED);
2520 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2521 return;
2522 }
2523
2524
2525 task = stmf_task_alloc(ict->ict_sess->ist_lport,
2526 ict->ict_sess->ist_stmf_sess, iscsi_tm->lun,
2527 0, STMF_TASK_EXT_NONE);
2528 if (task == NULL) {
2529 /*
2530 * If this happens, either the LU is in reset, couldn't
2531 * get memory, or some other condition in which we simply
2532 * can't complete this request. It would be nice to return
2533 * an error code like "busy" but the closest we have is
2534 * "rejected".
2535 */
2536 iscsit_send_task_mgmt_resp(tm_resp_pdu,
2537 SCSI_TCP_TM_RESP_REJECTED);
2538 iscsit_tm_task_free(tm_itask);
2539 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2540 return;
2541 }
2542
2543 tm_itask->it_tm_pdu = tm_resp_pdu;
2544 tm_itask->it_stmf_task = task;
2545 task->task_port_private = tm_itask;
2546 task->task_mgmt_function = tm_func;
2547 task->task_additional_flags = TASK_AF_NO_EXPECTED_XFER_LENGTH;
2548 task->task_priority = 0;
2549 task->task_max_nbufs = STMF_BUFS_MAX;
2550 task->task_cmd_seq_no = iscsi_tm->itt;
2551 task->task_expected_xfer_length = 0;
2552
2553 stmf_post_task(task, NULL);
2554 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2555 }
2556
2557 static void
2558 iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2559 {
2560 iscsi_nop_out_hdr_t *out = (iscsi_nop_out_hdr_t *)rx_pdu->isp_hdr;
2561 iscsi_nop_in_hdr_t *in;
2562 int resp_datalen;
2563 idm_pdu_t *resp;
2564
2565 /* Ignore the response from initiator */
2566 if ((out->itt == ISCSI_RSVD_TASK_TAG) ||
2567 (out->ttt != ISCSI_RSVD_TASK_TAG)) {
2568 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2569 return;
2570 }
2571
2572 /* Allocate a PDU to respond */
2573 resp_datalen = ntoh24(out->dlength);
2574 resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen);
2575 idm_pdu_init(resp, ict->ict_ic, NULL, NULL);
2576 if (resp_datalen > 0) {
2577 bcopy(rx_pdu->isp_data, resp->isp_data, resp_datalen);
2578 }
2579
2580 /*
2581 * When sending a NOP-In as a response to a NOP-Out from the initiator,
2582 * the target must respond with the same initiator task tag that was
2583 * provided in the NOP-Out request, the target transfer tag must be
2584 * ISCSI_RSVD_TASK_TAG (0xffffffff) and StatSN will contain the next
2585 * status sequence number. The StatSN for the connection is advanced
2586 * after this PDU is sent.
2587 */
2588 in = (iscsi_nop_in_hdr_t *)resp->isp_hdr;
2589 bzero(in, sizeof (*in));
2590 in->opcode = ISCSI_OP_NOOP_IN;
2591 in->flags = ISCSI_FLAG_FINAL;
2592 bcopy(out->lun, in->lun, 8);
2593 in->itt = out->itt;
2594 in->ttt = ISCSI_RSVD_TASK_TAG;
2595 hton24(in->dlength, resp_datalen);
2596 resp->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2597 /* Any other field in resp to be set? */
2598 iscsit_pdu_tx(resp);
2599 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2600 }
2601
2602 static void
2603 iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2604 {
2605
2606 /*
2607 * Submit PDU to login state machine. State machine will free the
2608 * PDU.
2609 */
2610 iscsit_login_sm_event(ict, ILE_LOGIN_RCV, rx_pdu);
2611 }
2612
2613 void
2614 iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2615 {
2616 iscsi_logout_hdr_t *logout_req =
2617 (iscsi_logout_hdr_t *)rx_pdu->isp_hdr;
2618 iscsi_logout_rsp_hdr_t *logout_rsp;
2619 idm_pdu_t *resp;
2620
2621 /* Allocate a PDU to respond */
2622 resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0);
2623 idm_pdu_init(resp, ict->ict_ic, NULL, NULL);
2624 /*
2625 * The StatSN is to be sent to the initiator,
2626 * it is not required to increment the number
2627 * as the connection is terminating.
2628 */
2629 resp->isp_flags |= IDM_PDU_SET_STATSN;
2630 /*
2631 * Logout results in the immediate termination of all tasks except
2632 * if the logout reason is ISCSI_LOGOUT_REASON_RECOVERY. The
2633 * connection state machine will drive this task cleanup automatically
2634 * so we don't need to handle that here.
2635 */
2636 logout_rsp = (iscsi_logout_rsp_hdr_t *)resp->isp_hdr;
2637 bzero(logout_rsp, sizeof (*logout_rsp));
2638 logout_rsp->opcode = ISCSI_OP_LOGOUT_RSP;
2639 logout_rsp->flags = ISCSI_FLAG_FINAL;
2640 logout_rsp->itt = logout_req->itt;
2641 if ((logout_req->flags & ISCSI_FLAG_LOGOUT_REASON_MASK) >
2642 ISCSI_LOGOUT_REASON_RECOVERY) {
2643 logout_rsp->response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED;
2644 } else {
2645 logout_rsp->response = ISCSI_LOGOUT_SUCCESS;
2646 }
2647
2648 iscsit_pdu_tx(resp);
2649 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2650 }
2651
2652 /*
2653 * Calculate the number of outstanding commands we can process
2654 */
2655 int
2656 iscsit_cmd_window()
2657 {
2658 /*
2659 * Instead of using a pre-defined constant for the command window,
2660 * it should be made confiurable and dynamic. With MC/S, sequence
2661 * numbers will be used up at a much faster rate than with SC/S.
2662 */
2663 return (ISCSIT_MAX_WINDOW);
2664 }
2665
2666 /*
2667 * Set local registers based on incoming PDU
2668 */
2669 void
2670 iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2671 {
2672 iscsit_sess_t *ist;
2673 iscsi_scsi_cmd_hdr_t *req;
2674
2675 ist = ict->ict_sess;
2676
2677 req = (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
2678 if (req->opcode & ISCSI_OP_IMMEDIATE) {
2679 /* no cmdsn increment for immediate PDUs */
2680 return;
2681 }
2682
2683 /* Ensure that the ExpCmdSN advances in an orderly manner */
2684 mutex_enter(&ist->ist_sn_mutex);
2685 ist->ist_expcmdsn = ntohl(req->cmdsn) + 1;
2686 ist->ist_maxcmdsn = ntohl(req->cmdsn) + iscsit_cmd_window();
2687 mutex_exit(&ist->ist_sn_mutex);
2688 }
2689
2690 /*
2691 * Wrapper funtion, calls iscsi_calc_rspsn and idm_pdu_tx
2692 */
2693 void
2694 iscsit_pdu_tx(idm_pdu_t *pdu)
2695 {
2696 iscsit_conn_t *ict = pdu->isp_ic->ic_handle;
2697 iscsi_scsi_rsp_hdr_t *rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
2698 iscsit_sess_t *ist = ict->ict_sess;
2699
2700 /*
2701 * The command sequence numbers are session-wide and must stay
2702 * consistent across the transfer, so protect the cmdsn with a
2703 * mutex lock on the session. The status sequence number will
2704 * be updated just before the transport layer transmits the PDU.
2705 */
2706
2707 mutex_enter(&ict->ict_sess->ist_sn_mutex);
2708 /* Set ExpCmdSN and MaxCmdSN */
2709 rsp->maxcmdsn = htonl(ist->ist_maxcmdsn);
2710 rsp->expcmdsn = htonl(ist->ist_expcmdsn);
2711 idm_pdu_tx(pdu);
2712 mutex_exit(&ict->ict_sess->ist_sn_mutex);
2713 }
2714
2715 /*
2716 * Internal functions
2717 */
2718
2719 void
2720 iscsit_send_async_event(iscsit_conn_t *ict, uint8_t event)
2721 {
2722 idm_pdu_t *abt;
2723 iscsi_async_evt_hdr_t *async_abt;
2724
2725 /*
2726 * Get a PDU to build the abort request.
2727 */
2728 abt = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0);
2729 if (abt == NULL) {
2730 idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, 0);
2731 return;
2732 }
2733
2734 /*
2735 * A asynchronous message is sent by the target to request a logout.
2736 * The StatSN for the connection is advanced after the PDU is sent
2737 * to allow for initiator and target state synchronization.
2738 */
2739 idm_pdu_init(abt, ict->ict_ic, NULL, NULL);
2740 abt->isp_datalen = 0;
2741 abt->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2742
2743 async_abt = (iscsi_async_evt_hdr_t *)abt->isp_hdr;
2744 bzero(async_abt, sizeof (*async_abt));
2745 async_abt->opcode = ISCSI_OP_ASYNC_EVENT;
2746 async_abt->async_event = event;
2747 async_abt->flags = ISCSI_FLAG_FINAL;
2748 async_abt->rsvd4[0] = 0xff;
2749 async_abt->rsvd4[1] = 0xff;
2750 async_abt->rsvd4[2] = 0xff;
2751 async_abt->rsvd4[3] = 0xff;
2752
2753 switch (event) {
2754 case ISCSI_ASYNC_EVENT_REQUEST_LOGOUT:
2755 async_abt->param3 = htons(IDM_LOGOUT_SECONDS);
2756 break;
2757 case ISCSI_ASYNC_EVENT_SCSI_EVENT:
2758 case ISCSI_ASYNC_EVENT_DROPPING_CONNECTION:
2759 case ISCSI_ASYNC_EVENT_DROPPING_ALL_CONNECTIONS:
2760 case ISCSI_ASYNC_EVENT_PARAM_NEGOTIATION:
2761 default:
2762 ASSERT(0);
2763 }
2764
2765 iscsit_pdu_tx(abt);
2766 }
2767
2768 void
2769 iscsit_send_reject(iscsit_conn_t *ict, idm_pdu_t *rejected_pdu, uint8_t reason)
2770 {
2771 idm_pdu_t *reject_pdu;
2772 iscsi_reject_rsp_hdr_t *reject;
2773
2774 /*
2775 * Get a PDU to build the abort request.
2776 */
2777 reject_pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t),
2778 rejected_pdu->isp_hdrlen);
2779 if (reject_pdu == NULL) {
2780 idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, 0);
2781 return;
2782 }
2783 idm_pdu_init(reject_pdu, ict->ict_ic, NULL, NULL);
2784 /* StatSN is advanced after a Reject PDU */
2785 reject_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2786 reject_pdu->isp_datalen = rejected_pdu->isp_hdrlen;
2787 bcopy(rejected_pdu->isp_hdr, reject_pdu->isp_data,
2788 rejected_pdu->isp_hdrlen);
2789
2790 reject = (iscsi_reject_rsp_hdr_t *)reject_pdu->isp_hdr;
2791 bzero(reject, sizeof (*reject));
2792 reject->opcode = ISCSI_OP_REJECT_MSG;
2793 reject->reason = reason;
2794 reject->flags = ISCSI_FLAG_FINAL;
2795 hton24(reject->dlength, rejected_pdu->isp_hdrlen);
2796 reject->must_be_ff[0] = 0xff;
2797 reject->must_be_ff[1] = 0xff;
2798 reject->must_be_ff[2] = 0xff;
2799 reject->must_be_ff[3] = 0xff;
2800
2801 iscsit_pdu_tx(reject_pdu);
2802 }
2803
2804
2805 static iscsit_task_t *
2806 iscsit_task_alloc(iscsit_conn_t *ict)
2807 {
2808 iscsit_task_t *itask;
2809 iscsit_buf_t *immed_ibuf;
2810
2811 /*
2812 * Possible items to pre-alloc if we cache iscsit_task_t's:
2813 *
2814 * Status PDU w/ sense buffer
2815 * stmf_data_buf_t for immediate data
2816 */
2817 itask = kmem_alloc(sizeof (iscsit_task_t) + sizeof (iscsit_buf_t) +
2818 sizeof (stmf_data_buf_t), KM_NOSLEEP);
2819 if (itask != NULL) {
2820 mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL);
2821 itask->it_aborted = itask->it_stmf_abort =
2822 itask->it_tm_task = 0;
2823
2824 immed_ibuf = (iscsit_buf_t *)(itask + 1);
2825 bzero(immed_ibuf, sizeof (*immed_ibuf));
2826 immed_ibuf->ibuf_is_immed = B_TRUE;
2827 immed_ibuf->ibuf_stmf_buf = (stmf_data_buf_t *)(immed_ibuf + 1);
2828
2829 bzero(immed_ibuf->ibuf_stmf_buf, sizeof (stmf_data_buf_t));
2830 immed_ibuf->ibuf_stmf_buf->db_port_private = immed_ibuf;
2831 immed_ibuf->ibuf_stmf_buf->db_sglist_length = 1;
2832 immed_ibuf->ibuf_stmf_buf->db_flags = DB_DIRECTION_FROM_RPORT |
2833 DB_DONT_CACHE;
2834 itask->it_immed_data = immed_ibuf;
2835 itask->it_idm_task = idm_task_alloc(ict->ict_ic);
2836 if (itask->it_idm_task != NULL) {
2837 itask->it_idm_task->idt_private = itask;
2838 itask->it_ict = ict;
2839 itask->it_ttt = itask->it_idm_task->idt_tt;
2840 return (itask);
2841 } else {
2842 kmem_free(itask, sizeof (iscsit_task_t) +
2843 sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t));
2844 }
2845 }
2846
2847 return (NULL);
2848 }
2849
2850 static void
2851 iscsit_task_free(iscsit_task_t *itask)
2852 {
2853 idm_task_free(itask->it_idm_task);
2854 mutex_destroy(&itask->it_mutex);
2855 kmem_free(itask, sizeof (iscsit_task_t) +
2856 sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t));
2857 }
2858
2859 static iscsit_task_t *
2860 iscsit_tm_task_alloc(iscsit_conn_t *ict)
2861 {
2862 iscsit_task_t *itask;
2863
2864 itask = kmem_zalloc(sizeof (iscsit_task_t), KM_NOSLEEP);
2865 if (itask != NULL) {
2866 idm_conn_hold(ict->ict_ic);
2867 mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL);
2868 itask->it_aborted = itask->it_stmf_abort =
2869 itask->it_tm_responded = 0;
2870 itask->it_tm_pdu = NULL;
2871 itask->it_tm_task = 1;
2872 itask->it_ict = ict;
2873 }
2874
2875 return (itask);
2876 }
2877
2878 static void
2879 iscsit_tm_task_free(iscsit_task_t *itask)
2880 {
2881 /*
2882 * If we responded then the call to idm_pdu_complete will free the
2883 * PDU. Otherwise we got aborted before the TM function could
2884 * complete and we need to free the PDU explicitly.
2885 */
2886 if (itask->it_tm_pdu != NULL && !itask->it_tm_responded)
2887 idm_pdu_free(itask->it_tm_pdu);
2888 idm_conn_rele(itask->it_ict->ict_ic);
2889 mutex_destroy(&itask->it_mutex);
2890 kmem_free(itask, sizeof (iscsit_task_t));
2891 }
2892
2893 static idm_status_t
2894 iscsit_task_start(iscsit_task_t *itask)
2895 {
2896 iscsit_sess_t *ist = itask->it_ict->ict_sess;
2897 avl_index_t where;
2898
2899 /*
2900 * Sanity check the ITT and ensure that this task does not already
2901 * exist. If not then add the task to the session task list.
2902 */
2903 mutex_enter(&ist->ist_mutex);
2904 mutex_enter(&itask->it_mutex);
2905 itask->it_active = 1;
2906 if (avl_find(&ist->ist_task_list, itask, &where) == NULL) {
2907 /* New task, add to AVL */
2908 avl_insert(&ist->ist_task_list, itask, where);
2909 mutex_exit(&itask->it_mutex);
2910 mutex_exit(&ist->ist_mutex);
2911 return (IDM_STATUS_SUCCESS);
2912 }
2913 mutex_exit(&itask->it_mutex);
2914 mutex_exit(&ist->ist_mutex);
2915
2916 return (IDM_STATUS_REJECT);
2917 }
2918
2919 static void
2920 iscsit_task_done(iscsit_task_t *itask)
2921 {
2922 iscsit_sess_t *ist = itask->it_ict->ict_sess;
2923
2924 mutex_enter(&ist->ist_mutex);
2925 mutex_enter(&itask->it_mutex);
2926 if (itask->it_active) {
2927 avl_remove(&ist->ist_task_list, itask);
2928 itask->it_active = 0;
2929 }
2930 mutex_exit(&itask->it_mutex);
2931 mutex_exit(&ist->ist_mutex);
2932 }
2933
2934 /*
2935 * iscsit status PDU cache
2936 */
2937
2938 /*ARGSUSED*/
2939 static int
2940 iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags)
2941 {
2942 idm_pdu_t *pdu = pdu_void;
2943 iscsi_scsi_rsp_hdr_t *rsp;
2944
2945 bzero(pdu, sizeof (idm_pdu_t));
2946 pdu->isp_callback = iscsit_send_good_status_done;
2947 pdu->isp_magic = IDM_PDU_MAGIC;
2948 pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); /* Ptr arithmetic */
2949 pdu->isp_hdrlen = sizeof (iscsi_hdr_t);
2950
2951 /* Setup status response */
2952 rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
2953 bzero(rsp, sizeof (*rsp));
2954 rsp->opcode = ISCSI_OP_SCSI_RSP;
2955 rsp->flags = ISCSI_FLAG_FINAL;
2956 rsp->response = ISCSI_STATUS_CMD_COMPLETED;
2957
2958 return (0);
2959 }
2960
2961 /*
2962 * iscsit private data handler
2963 */
2964
2965 /*ARGSUSED*/
2966 static void
2967 iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags)
2968 {
2969 it_config_t *cfg;
2970 nvlist_t *nvl;
2971 iscsit_service_enabled_t old_state;
2972
2973 if ((cmd != STMF_PROVIDER_DATA_UPDATED) || (arg == NULL)) {
2974 return;
2975 }
2976
2977 nvl = (nvlist_t *)arg;
2978
2979 /* Translate nvlist */
2980 if (it_nv_to_config(nvl, &cfg) != 0) {
2981 cmn_err(CE_WARN, "Configuration is invalid");
2982 return;
2983 }
2984
2985 /* Check that no iSCSI ioctl is currently running */
2986 mutex_enter(&iscsit_global.global_state_mutex);
2987 old_state = iscsit_global.global_svc_state;
2988 switch (iscsit_global.global_svc_state) {
2989 case ISE_ENABLED:
2990 case ISE_DISABLED:
2991 iscsit_global.global_svc_state = ISE_BUSY;
2992 break;
2993 case ISE_ENABLING:
2994 /*
2995 * It is OK for the iscsit_pp_cb to be called from inside of
2996 * an iSCSI ioctl only if we are currently executing inside
2997 * of stmf_register_port_provider.
2998 */
2999 ASSERT((flags & STMF_PCB_PREG_COMPLETE) != 0);
3000 break;
3001 default:
3002 cmn_err(CE_WARN, "iscsit_pp_cb called when global_svc_state"
3003 " is not ENABLED(0x%x) -- ignoring",
3004 iscsit_global.global_svc_state);
3005 mutex_exit(&iscsit_global.global_state_mutex);
3006 it_config_free_cmn(cfg);
3007 return;
3008 }
3009 mutex_exit(&iscsit_global.global_state_mutex);
3010
3011 /* Update config */
3012 (void) iscsit_config_merge(cfg);
3013
3014 it_config_free_cmn(cfg);
3015
3016 /* Restore old iSCSI driver global state */
3017 mutex_enter(&iscsit_global.global_state_mutex);
3018 ASSERT(iscsit_global.global_svc_state == ISE_BUSY ||
3019 iscsit_global.global_svc_state == ISE_ENABLING);
3020 iscsit_global.global_svc_state = old_state;
3021 mutex_exit(&iscsit_global.global_state_mutex);
3022 }
3023
3024
3025 static it_cfg_status_t
3026 iscsit_config_merge(it_config_t *in_cfg)
3027 {
3028 it_cfg_status_t status;
3029 it_config_t *cfg;
3030 it_config_t tmp_cfg;
3031 list_t tpg_del_list;
3032
3033 if (in_cfg) {
3034 cfg = in_cfg;
3035 } else {
3036 /* Make empty config */
3037 bzero(&tmp_cfg, sizeof (tmp_cfg));
3038 cfg = &tmp_cfg;
3039 }
3040
3041 list_create(&tpg_del_list, sizeof (iscsit_tpg_t),
3042 offsetof(iscsit_tpg_t, tpg_delete_ln));
3043
3044 /*
3045 * Update targets, initiator contexts, target portal groups,
3046 * and iSNS client
3047 */
3048 ISCSIT_GLOBAL_LOCK(RW_WRITER);
3049 if (((status = iscsit_config_merge_tpg(cfg, &tpg_del_list))
3050 != 0) ||
3051 ((status = iscsit_config_merge_tgt(cfg)) != 0) ||
3052 ((status = iscsit_config_merge_ini(cfg)) != 0) ||
3053 ((status = isnst_config_merge(cfg)) != 0)) {
3054 ISCSIT_GLOBAL_UNLOCK();
3055 return (status);
3056 }
3057
3058 /* Update other global config parameters */
3059 if (iscsit_global.global_props) {
3060 nvlist_free(iscsit_global.global_props);
3061 iscsit_global.global_props = NULL;
3062 }
3063 if (in_cfg) {
3064 (void) nvlist_dup(cfg->config_global_properties,
3065 &iscsit_global.global_props, KM_SLEEP);
3066 }
3067 ISCSIT_GLOBAL_UNLOCK();
3068
3069 iscsit_config_destroy_tpgs(&tpg_del_list);
3070
3071 list_destroy(&tpg_del_list);
3072
3073 return (ITCFG_SUCCESS);
3074 }
3075
3076 /*
3077 * iscsit_sna_lt[e]
3078 *
3079 * Compare serial numbers using serial number arithmetic as defined in
3080 * RFC 1982.
3081 *
3082 * NOTE: This code is duplicated in the isns server. It ought to be common.
3083 */
3084
3085 static int
3086 iscsit_sna_lt(uint32_t sn1, uint32_t sn2)
3087 {
3088 return ((sn1 != sn2) &&
3089 (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) ||
3090 ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK))));
3091 }
3092
3093 static int
3094 iscsit_sna_lte(uint32_t sn1, uint32_t sn2)
3095 {
3096 return ((sn1 == sn2) ||
3097 (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) ||
3098 ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK))));
3099 }
3100
3101
3102 static boolean_t
3103 iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn)
3104 {
3105 iscsit_sess_t *ist = ict->ict_sess;
3106 int rval = B_TRUE;
3107
3108 ist = ict->ict_sess;
3109
3110 mutex_enter(&ist->ist_sn_mutex);
3111
3112 /*
3113 * If cmdsn is less than ist_expcmdsn - iscsit_cmd_window() or
3114 * greater than ist_expcmdsn, it's not in the window.
3115 */
3116
3117 if (iscsit_sna_lt(cmdsn, (ist->ist_expcmdsn - iscsit_cmd_window())) ||
3118 !iscsit_sna_lte(cmdsn, ist->ist_expcmdsn)) {
3119 rval = B_FALSE;
3120 }
3121
3122 mutex_exit(&ist->ist_sn_mutex);
3123
3124 return (rval);
3125 }
3126
3127 /*
3128 * iscsit_check_cmdsn_and_queue
3129 *
3130 * Independent of the order in which the iSCSI target receives non-immediate
3131 * command PDU across the entire session and any multiple connections within
3132 * the session, the target must deliver the commands to the SCSI layer in
3133 * CmdSN order. So out-of-order non-immediate commands are queued up on a
3134 * session-wide wait queue. Duplicate commands are ignored.
3135 *
3136 * returns B_TRUE for commands which can be executed immediately (are
3137 * non-deferred), B_FALSE for cases where a command was deferred or invalid.
3138 */
3139 static boolean_t
3140 iscsit_check_cmdsn_and_queue(idm_pdu_t *rx_pdu)
3141 {
3142 idm_conn_t *ic = rx_pdu->isp_ic;
3143 iscsit_conn_t *ict = ic->ic_handle;
3144 iscsit_sess_t *ist = ict->ict_sess;
3145 iscsi_scsi_cmd_hdr_t *hdr = (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
3146
3147 mutex_enter(&ist->ist_sn_mutex);
3148 if (hdr->opcode & ISCSI_OP_IMMEDIATE) {
3149 /* do not queue, handle it immediately */
3150 DTRACE_PROBE2(immediate__cmd, iscsit_sess_t *, ist,
3151 idm_pdu_t *, rx_pdu);
3152 mutex_exit(&ist->ist_sn_mutex);
3153 return (B_TRUE);
3154 }
3155 /*
3156 * See RFC3270 3.1.1.2: non-immediate commands outside of the
3157 * expected window (from expcmdsn to maxcmdsn, inclusive)
3158 * should be silently ignored.
3159 */
3160 if (iscsit_sna_lt(ist->ist_expcmdsn, ntohl(hdr->cmdsn)) &&
3161 iscsit_sna_lt(ntohl(hdr->cmdsn), ist->ist_maxcmdsn)) {
3162 /*
3163 * Out-of-order commands (cmdSN higher than ExpCmdSN)
3164 * are staged on a fixed-size circular buffer until
3165 * the missing command is delivered to the SCSI layer.
3166 * Irrespective of the order of insertion into the
3167 * staging queue, the commands are processed out of the
3168 * queue in cmdSN order only.
3169 */
3170 rx_pdu->isp_queue_time = gethrtime();
3171 iscsit_add_pdu_to_queue(ist, rx_pdu);
3172 mutex_exit(&ist->ist_sn_mutex);
3173 return (B_FALSE);
3174 } else if (iscsit_sna_lt(ntohl(hdr->cmdsn), ist->ist_expcmdsn) ||
3175 iscsit_sna_lt(ist->ist_maxcmdsn, ntohl(hdr->cmdsn))) {
3176 /*
3177 * See above, this command is outside of our acceptable
3178 * window, we need to discard/complete.
3179 */
3180 DTRACE_PROBE3(cmdsn__lt__expcmdsn, iscsit_sess_t *, ist,
3181 iscsit_conn_t *, ict, idm_pdu_t *, rx_pdu);
3182 mutex_exit(&ist->ist_sn_mutex);
3183 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
3184 /*
3185 * tell our callers that the PDU "finished."
3186 */
3187 return (B_FALSE);
3188 } else {
3189 mutex_exit(&ist->ist_sn_mutex);
3190 return (B_TRUE);
3191 }
3192 }
3193
3194 /*
3195 * iscsit_add_pdu_to_queue() adds PDUs into the array indexed by
3196 * their cmdsn value. The length of the array is kept above the
3197 * maximum window size. The window keeps the cmdsn within a range
3198 * such that there are no collisons. e.g. the assumption is that
3199 * the windowing checks make it impossible to receive PDUs that
3200 * index into the same location in the array.
3201 */
3202 static void
3203 iscsit_add_pdu_to_queue(iscsit_sess_t *ist, idm_pdu_t *rx_pdu)
3204 {
3205 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue;
3206 iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle;
3207 uint32_t cmdsn =
3208 ((iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr)->cmdsn;
3209 uint32_t index;
3210
3211 ASSERT(MUTEX_HELD(&ist->ist_sn_mutex));
3212 /*
3213 * If the connection is being torn down, then
3214 * don't add the PDU to the staging queue
3215 */
3216 mutex_enter(&ict->ict_mutex);
3217 if (ict->ict_lost) {
3218 mutex_exit(&ict->ict_mutex);
3219 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
3220 return;
3221 }
3222 iscsit_conn_dispatch_hold(ict);
3223 mutex_exit(&ict->ict_mutex);
3224
3225 index = ntohl(cmdsn) % ISCSIT_RXPDU_QUEUE_LEN;
3226 /*
3227 * In the normal case, assuming that the Initiator is not
3228 * buggy and that we don't have packet duplication occuring,
3229 * the entry in the array will be NULL. However, we may have
3230 * received a duplicate PDU with cmdsn > expsn , and in that
3231 * case we just ignore this PDU -- the previously received one
3232 * remains queued for processing. We need to be careful not
3233 * to leak this one however.
3234 */
3235 if (cbuf->cb_buffer[index] != NULL) {
3236 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
3237 } else {
3238 cbuf->cb_buffer[index] = rx_pdu;
3239 cbuf->cb_num_elems++;
3240 }
3241 }
3242
3243 static idm_pdu_t *
3244 iscsit_remove_pdu_from_queue(iscsit_sess_t *ist, uint32_t cmdsn)
3245 {
3246 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue;
3247 idm_pdu_t *pdu = NULL;
3248 uint32_t index;
3249
3250 ASSERT(MUTEX_HELD(&ist->ist_sn_mutex));
3251 index = cmdsn % ISCSIT_RXPDU_QUEUE_LEN;
3252 if ((pdu = cbuf->cb_buffer[index]) != NULL) {
3253 ASSERT(cmdsn ==
3254 ntohl(((iscsi_scsi_cmd_hdr_t *)pdu->isp_hdr)->cmdsn));
3255 cbuf->cb_buffer[index] = NULL;
3256 cbuf->cb_num_elems--;
3257 return (pdu);
3258 }
3259 return (NULL);
3260 }
3261
3262 /*
3263 * iscsit_process_pdu_in_queue() finds the next pdu in sequence
3264 * and posts it to the SCSI layer
3265 */
3266 static void
3267 iscsit_process_pdu_in_queue(iscsit_sess_t *ist)
3268 {
3269 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue;
3270 idm_pdu_t *pdu = NULL;
3271 uint32_t expcmdsn;
3272
3273 for (;;) {
3274 mutex_enter(&ist->ist_sn_mutex);
3275 if (cbuf->cb_num_elems == 0) {
3276 mutex_exit(&ist->ist_sn_mutex);
3277 break;
3278 }
3279 expcmdsn = ist->ist_expcmdsn;
3280 if ((pdu = iscsit_remove_pdu_from_queue(ist, expcmdsn))
3281 == NULL) {
3282 mutex_exit(&ist->ist_sn_mutex);
3283 break;
3284 }
3285 mutex_exit(&ist->ist_sn_mutex);
3286 iscsit_post_staged_pdu(pdu);
3287 }
3288 }
3289
3290 static void
3291 iscsit_post_staged_pdu(idm_pdu_t *rx_pdu)
3292 {
3293 iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle;
3294
3295 /* Post the PDU to the SCSI layer */
3296 switch (IDM_PDU_OPCODE(rx_pdu)) {
3297 case ISCSI_OP_NOOP_OUT:
3298 iscsit_set_cmdsn(ict, rx_pdu);
3299 iscsit_pdu_op_noop(ict, rx_pdu);
3300 break;
3301 case ISCSI_OP_TEXT_CMD:
3302 iscsit_set_cmdsn(ict, rx_pdu);
3303 iscsit_pdu_op_text_cmd(ict, rx_pdu);
3304 break;
3305 case ISCSI_OP_SCSI_TASK_MGT_MSG:
3306 iscsit_set_cmdsn(ict, rx_pdu);
3307 iscsit_op_scsi_task_mgmt(ict, rx_pdu);
3308 break;
3309 case ISCSI_OP_SCSI_CMD:
3310 /* cmdSN will be incremented after creating itask */
3311 iscsit_post_scsi_cmd(rx_pdu->isp_ic, rx_pdu);
3312 break;
3313 case ISCSI_OP_LOGOUT_CMD:
3314 iscsit_set_cmdsn(ict, rx_pdu);
3315 iscsit_pdu_op_logout_cmd(ict, rx_pdu);
3316 break;
3317 default:
3318 /* No other PDUs should be placed on the queue */
3319 ASSERT(0);
3320 }
3321 iscsit_conn_dispatch_rele(ict); /* release hold on the conn */
3322 }
3323
3324 /* ARGSUSED */
3325 void
3326 iscsit_rxpdu_queue_monitor_start(void)
3327 {
3328 mutex_enter(&iscsit_rxpdu_queue_monitor_mutex);
3329 if (iscsit_rxpdu_queue_monitor_thr_running) {
3330 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex);
3331 return;
3332 }
3333 iscsit_rxpdu_queue_monitor_thr_id =
3334 thread_create(NULL, 0, iscsit_rxpdu_queue_monitor, NULL,
3335 0, &p0, TS_RUN, minclsyspri);
3336 while (!iscsit_rxpdu_queue_monitor_thr_running) {
3337 cv_wait(&iscsit_rxpdu_queue_monitor_cv,
3338 &iscsit_rxpdu_queue_monitor_mutex);
3339 }
3340 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex);
3341
3342 }
3343
3344 /* ARGSUSED */
3345 void
3346 iscsit_rxpdu_queue_monitor_stop(void)
3347 {
3348 mutex_enter(&iscsit_rxpdu_queue_monitor_mutex);
3349 if (iscsit_rxpdu_queue_monitor_thr_running) {
3350 iscsit_rxpdu_queue_monitor_thr_running = B_FALSE;
3351 cv_signal(&iscsit_rxpdu_queue_monitor_cv);
3352 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex);
3353
3354 thread_join(iscsit_rxpdu_queue_monitor_thr_did);
3355 return;
3356 }
3357 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex);
3358 }
3359
3360 /*
3361 * A separate thread is used to scan the staging queue on all the
3362 * sessions, If a delayed PDU does not arrive within a timeout, the
3363 * target will advance to the staged PDU that is next in sequence
3364 * and exceeded the threshold wait time. It is up to the initiator
3365 * to note that the target has not acknowledged a particular cmdsn
3366 * and take appropriate action.
3367 */
3368 /* ARGSUSED */
3369 static void
3370 iscsit_rxpdu_queue_monitor(void *arg)
3371 {
3372 iscsit_tgt_t *tgt;
3373 iscsit_sess_t *ist;
3374
3375 mutex_enter(&iscsit_rxpdu_queue_monitor_mutex);
3376 iscsit_rxpdu_queue_monitor_thr_did = curthread->t_did;
3377 iscsit_rxpdu_queue_monitor_thr_running = B_TRUE;
3378 cv_signal(&iscsit_rxpdu_queue_monitor_cv);
3379
3380 while (iscsit_rxpdu_queue_monitor_thr_running) {
3381 ISCSIT_GLOBAL_LOCK(RW_READER);
3382 for (tgt = avl_first(&iscsit_global.global_target_list);
3383 tgt != NULL;
3384 tgt = AVL_NEXT(&iscsit_global.global_target_list, tgt)) {
3385 mutex_enter(&tgt->target_mutex);
3386 for (ist = avl_first(&tgt->target_sess_list);
3387 ist != NULL;
3388 ist = AVL_NEXT(&tgt->target_sess_list, ist)) {
3389
3390 iscsit_rxpdu_queue_monitor_session(ist);
3391 }
3392 mutex_exit(&tgt->target_mutex);
3393 }
3394 ISCSIT_GLOBAL_UNLOCK();
3395 if (iscsit_rxpdu_queue_monitor_thr_running == B_FALSE) {
3396 break;
3397 }
3398 (void) cv_reltimedwait(&iscsit_rxpdu_queue_monitor_cv,
3399 &iscsit_rxpdu_queue_monitor_mutex,
3400 ISCSIT_RXPDU_QUEUE_MONITOR_INTERVAL * drv_usectohz(1000000),
3401 TR_CLOCK_TICK);
3402 }
3403 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex);
3404 thread_exit();
3405 }
3406
3407 static void
3408 iscsit_rxpdu_queue_monitor_session(iscsit_sess_t *ist)
3409 {
3410 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue;
3411 idm_pdu_t *next_pdu = NULL;
3412 uint32_t index, next_cmdsn, i;
3413
3414 /*
3415 * Assume that all PDUs in the staging queue have a cmdsn >= expcmdsn.
3416 * Starting with the expcmdsn, iterate over the staged PDUs to find
3417 * the next PDU with a wait time greater than the threshold. If found
3418 * advance the staged PDU to the SCSI layer, skipping over the missing
3419 * PDU(s) to get past the hole in the command sequence. It is up to
3420 * the initiator to note that the target has not acknowledged a cmdsn
3421 * and take appropriate action.
3422 *
3423 * Since the PDU(s) arrive in any random order, it is possible that
3424 * that the actual wait time for a particular PDU is much longer than
3425 * the defined threshold. e.g. Consider a case where commands are sent
3426 * over 4 different connections, and cmdsn = 1004 arrives first, then
3427 * 1003, and 1002 and 1001 are lost due to a connection failure.
3428 * So now 1003 is waiting for 1002 to be delivered, and although the
3429 * wait time of 1004 > wait time of 1003, only 1003 will be considered
3430 * by the monitor thread. 1004 will be automatically processed by
3431 * iscsit_process_pdu_in_queue() once the scan is complete and the
3432 * expcmdsn becomes current.
3433 */
3434 mutex_enter(&ist->ist_sn_mutex);
3435 cbuf = ist->ist_rxpdu_queue;
3436 if (cbuf->cb_num_elems == 0) {
3437 mutex_exit(&ist->ist_sn_mutex);
3438 return;
3439 }
3440 for (next_pdu = NULL, i = 0; ; i++) {
3441 next_cmdsn = ist->ist_expcmdsn + i; /* start at expcmdsn */
3442 index = next_cmdsn % ISCSIT_RXPDU_QUEUE_LEN;
3443 if ((next_pdu = cbuf->cb_buffer[index]) != NULL) {
3444 /*
3445 * If the PDU wait time has not exceeded threshold
3446 * stop scanning the staging queue until the timer
3447 * fires again
3448 */
3449 if ((gethrtime() - next_pdu->isp_queue_time)
3450 < (rxpdu_queue_threshold * NANOSEC)) {
3451 mutex_exit(&ist->ist_sn_mutex);
3452 return;
3453 }
3454 /*
3455 * Remove the next PDU from the queue and post it
3456 * to the SCSI layer, skipping over the missing
3457 * PDU. Stop scanning the staging queue until
3458 * the monitor timer fires again
3459 */
3460 (void) iscsit_remove_pdu_from_queue(ist, next_cmdsn);
3461 mutex_exit(&ist->ist_sn_mutex);
3462 DTRACE_PROBE3(advanced__to__blocked__cmdsn,
3463 iscsit_sess_t *, ist, idm_pdu_t *, next_pdu,
3464 uint32_t, next_cmdsn);
3465 iscsit_post_staged_pdu(next_pdu);
3466 /* Deliver any subsequent PDUs immediately */
3467 iscsit_process_pdu_in_queue(ist);
3468 return;
3469 }
3470 /*
3471 * Skipping over i PDUs, e.g. a case where commands 1001 and
3472 * 1002 are lost in the network, skip over both and post 1003
3473 * expcmdsn then becomes 1004 at the end of the scan.
3474 */
3475 DTRACE_PROBE2(skipping__over__cmdsn, iscsit_sess_t *, ist,
3476 uint32_t, next_cmdsn);
3477 }
3478 /*
3479 * following the assumption, staged cmdsn >= expcmdsn, this statement
3480 * is never reached.
3481 */
3482 }
Community developed and maintained version of the OS/Net consolidation