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