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