Lines Matching defs:is
96 * XXX: This is global so the iscsi_unload() can access it.
189 static void iscsi_session_reconnect(struct iscsi_session *is);
190 static void iscsi_session_terminate(struct iscsi_session *is);
192 static struct iscsi_outstanding *iscsi_outstanding_find(struct iscsi_session *is,
194 static struct iscsi_outstanding *iscsi_outstanding_add(struct iscsi_session *is,
197 static void iscsi_outstanding_remove(struct iscsi_session *is,
203 struct iscsi_session *is;
206 is = PDU_SESSION(request);
208 ISCSI_SESSION_LOCK_ASSERT(is);
220 if (ISCSI_SNGT(is->is_cmdsn, is->is_maxcmdsn) &&
229 ISCSI_SESSION_DEBUG(is, "postponing send, CmdSN %u, "
231 is->is_cmdsn, is->is_expcmdsn, is->is_maxcmdsn,
236 bhssc->bhssc_cmdsn = htonl(is->is_cmdsn);
238 is->is_cmdsn++;
240 bhssc->bhssc_expstatsn = htonl(is->is_statsn + 1);
246 iscsi_session_send_postponed(struct iscsi_session *is)
251 ISCSI_SESSION_LOCK_ASSERT(is);
253 if (STAILQ_EMPTY(&is->is_postponed))
255 while ((request = STAILQ_FIRST(&is->is_postponed)) != NULL) {
259 STAILQ_REMOVE_HEAD(&is->is_postponed, ip_next);
262 xpt_release_simq(is->is_sim, 1);
268 struct iscsi_session *is;
271 is = PDU_SESSION(request);
272 ISCSI_SESSION_LOCK_ASSERT(is);
273 iscsi_session_send_postponed(is);
276 if (STAILQ_EMPTY(&is->is_postponed))
277 xpt_freeze_simq(is->is_sim, 1);
278 STAILQ_INSERT_TAIL(&is->is_postponed, request, ip_next);
287 struct iscsi_session *is;
289 is = PDU_SESSION(request);
290 ISCSI_SESSION_LOCK(is);
292 ISCSI_SESSION_UNLOCK(is);
296 iscsi_session_logout(struct iscsi_session *is)
301 request = icl_pdu_new(is->is_conn, M_NOWAIT);
312 iscsi_session_terminate_task(struct iscsi_session *is,
316 ISCSI_SESSION_LOCK_ASSERT(is);
324 ISCSI_SESSION_DEBUG(is, "freezing devq");
328 iscsi_outstanding_remove(is, io);
332 iscsi_session_terminate_tasks(struct iscsi_session *is, cam_status status)
336 ISCSI_SESSION_LOCK_ASSERT(is);
338 TAILQ_FOREACH_SAFE(io, &is->is_outstanding, io_next, tmp) {
339 iscsi_session_terminate_task(is, io, status);
344 iscsi_session_cleanup(struct iscsi_session *is, bool destroy_sim)
348 ISCSI_SESSION_LOCK_ASSERT(is);
353 if (is->is_sim != NULL && is->is_simq_frozen == false) {
354 ISCSI_SESSION_DEBUG(is, "freezing");
355 xpt_freeze_simq(is->is_sim, 1);
356 is->is_simq_frozen = true;
362 if (!STAILQ_EMPTY(&is->is_postponed))
363 xpt_release_simq(is->is_sim, 1);
364 while ((pdu = STAILQ_FIRST(&is->is_postponed)) != NULL) {
365 STAILQ_REMOVE_HEAD(&is->is_postponed, ip_next);
373 iscsi_session_terminate_tasks(is, CAM_REQUEUE_REQ);
377 iscsi_session_terminate_tasks(is, CAM_DEV_NOT_THERE);
379 if (is->is_sim == NULL)
382 ISCSI_SESSION_DEBUG(is, "deregistering SIM");
383 xpt_async(AC_LOST_DEVICE, is->is_path, NULL);
385 if (is->is_simq_frozen) {
386 is->is_simq_frozen = false;
387 xpt_release_simq(is->is_sim, 1);
390 xpt_free_path(is->is_path);
391 is->is_path = NULL;
392 xpt_bus_deregister(cam_sim_path(is->is_sim));
393 cam_sim_free(is->is_sim, TRUE /*free_devq*/);
394 is->is_sim = NULL;
395 is->is_devq = NULL;
399 iscsi_maintenance_thread_reconnect(struct iscsi_session *is)
408 so = is->is_conn->ic_socket;
419 sosetopt(is->is_conn->ic_socket, &sopt);
422 icl_conn_close(is->is_conn);
424 ISCSI_SESSION_LOCK(is);
426 is->is_connected = false;
427 is->is_reconnecting = false;
428 is->is_login_phase = false;
431 if (is->is_login_pdu != NULL) {
432 icl_pdu_free(is->is_login_pdu);
433 is->is_login_pdu = NULL;
435 cv_signal(&is->is_login_cv);
439 ISCSI_SESSION_DEBUG(is, "connection failed, destroying devices");
440 iscsi_session_cleanup(is, true);
442 iscsi_session_cleanup(is, false);
445 KASSERT(TAILQ_EMPTY(&is->is_outstanding),
447 KASSERT(STAILQ_EMPTY(&is->is_postponed),
450 if (is->is_conf.isc_enable == 0 && is->is_conf.isc_discovery == 0) {
451 ISCSI_SESSION_UNLOCK(is);
458 //ISCSI_SESSION_DEBUG(is, "waking up iscsid(8)");
459 is->is_waiting_for_iscsid = true;
460 strlcpy(is->is_reason, "Waiting for iscsid(8)", sizeof(is->is_reason));
461 is->is_timeout = 0;
462 ISCSI_SESSION_UNLOCK(is);
463 cv_signal(&is->is_softc->sc_cv);
467 iscsi_maintenance_thread_terminate(struct iscsi_session *is)
471 sc = is->is_softc;
473 TAILQ_REMOVE(&sc->sc_sessions, is, is_next);
476 icl_conn_close(is->is_conn);
477 callout_drain(&is->is_callout);
479 ISCSI_SESSION_LOCK(is);
481 KASSERT(is->is_terminating, ("is_terminating == false"));
484 if (is->is_login_pdu != NULL) {
485 icl_pdu_free(is->is_login_pdu);
486 is->is_login_pdu = NULL;
488 cv_signal(&is->is_login_cv);
491 iscsi_session_cleanup(is, true);
493 KASSERT(TAILQ_EMPTY(&is->is_outstanding),
495 KASSERT(STAILQ_EMPTY(&is->is_postponed),
498 ISCSI_SESSION_UNLOCK(is);
500 icl_conn_free(is->is_conn);
501 mtx_destroy(&is->is_lock);
502 cv_destroy(&is->is_maintenance_cv);
504 cv_destroy(&is->is_login_cv);
507 ISCSI_SESSION_DEBUG(is, "terminated");
508 free(is, M_ISCSI);
519 struct iscsi_session *is = arg;
521 ISCSI_SESSION_LOCK(is);
523 if (is->is_reconnecting == false &&
524 is->is_terminating == false &&
525 (STAILQ_EMPTY(&is->is_postponed) ||
526 ISCSI_SNGT(is->is_cmdsn, is->is_maxcmdsn)))
527 cv_wait(&is->is_maintenance_cv, &is->is_lock);
530 if (is->is_terminating) {
531 ISCSI_SESSION_UNLOCK(is);
532 iscsi_maintenance_thread_terminate(is);
537 if (is->is_reconnecting) {
538 ISCSI_SESSION_UNLOCK(is);
539 iscsi_maintenance_thread_reconnect(is);
540 ISCSI_SESSION_LOCK(is);
544 iscsi_session_send_postponed(is);
546 ISCSI_SESSION_UNLOCK(is);
550 iscsi_session_reconnect(struct iscsi_session *is)
558 if (is->is_reconnecting)
561 is->is_reconnecting = true;
562 cv_signal(&is->is_maintenance_cv);
566 iscsi_session_terminate(struct iscsi_session *is)
569 if (is->is_terminating)
572 is->is_terminating = true;
575 iscsi_session_logout(is);
577 cv_signal(&is->is_maintenance_cv);
585 struct iscsi_session *is;
589 is = context;
591 ISCSI_SESSION_LOCK(is);
592 if (is->is_terminating) {
593 ISCSI_SESSION_UNLOCK(is);
599 callout_schedule_sbt(&is->is_callout, sbt, pr, 0);
601 if (is->is_conf.isc_enable == 0)
604 is->is_timeout++;
606 if (is->is_waiting_for_iscsid) {
607 if (iscsid_timeout > 0 && is->is_timeout > iscsid_timeout) {
608 ISCSI_SESSION_WARN(is, "timed out waiting for iscsid(8) "
610 is->is_timeout);
616 if (is->is_login_phase) {
617 if (is->is_login_timeout > 0 && is->is_timeout > is->is_login_timeout) {
618 ISCSI_SESSION_WARN(is, "login timed out after %d seconds; "
619 "reconnecting", is->is_timeout);
625 if (is->is_ping_timeout <= 0) {
631 is->is_timeout = 0;
635 if (is->is_timeout >= is->is_ping_timeout) {
636 ISCSI_SESSION_WARN(is, "no ping reply (NOP-In) after %d seconds; "
637 "reconnecting", is->is_ping_timeout);
642 ISCSI_SESSION_UNLOCK(is);
652 if (is->is_timeout < 2)
655 request = icl_pdu_new(is->is_conn, M_NOWAIT);
657 ISCSI_SESSION_WARN(is, "failed to allocate PDU");
669 if (is->is_terminating) {
670 ISCSI_SESSION_UNLOCK(is);
674 ISCSI_SESSION_UNLOCK(is);
677 iscsi_session_reconnect(is);
684 struct iscsi_session *is;
687 is = PDU_SESSION(response);
689 ISCSI_SESSION_LOCK_ASSERT(is);
699 * is set to 1", so we also need to check the bit specific for
705 if (statsn != is->is_statsn && statsn != (is->is_statsn + 1)) {
706 /* XXX: This is normal situation for MCS */
707 ISCSI_SESSION_WARN(is, "PDU 0x%x StatSN %u != "
709 bhsdi->bhsdi_opcode, statsn, is->is_statsn);
710 iscsi_session_reconnect(is);
712 if (ISCSI_SNGT(statsn, is->is_statsn))
713 is->is_statsn = statsn;
720 ISCSI_SESSION_DEBUG(is,
724 if (ISCSI_SNGT(maxcmdsn, is->is_maxcmdsn)) {
725 is->is_maxcmdsn = maxcmdsn;
731 if (!STAILQ_EMPTY(&is->is_postponed))
732 cv_signal(&is->is_maintenance_cv);
733 } else if (ISCSI_SNLT(maxcmdsn, is->is_maxcmdsn)) {
734 /* XXX: This is normal situation for MCS */
735 ISCSI_SESSION_DEBUG(is,
737 maxcmdsn, is->is_maxcmdsn);
740 if (ISCSI_SNGT(expcmdsn, is->is_expcmdsn)) {
741 is->is_expcmdsn = expcmdsn;
742 } else if (ISCSI_SNLT(expcmdsn, is->is_expcmdsn)) {
743 /* XXX: This is normal situation for MCS */
744 ISCSI_SESSION_DEBUG(is,
746 expcmdsn, is->is_expcmdsn);
752 * The purpose of the timeout is to reset the connection when it stalls;
756 is->is_timeout = 0;
762 struct iscsi_session *is;
764 is = PDU_SESSION(response);
766 ISCSI_SESSION_LOCK(is);
771 if (is->is_login_phase) {
772 if (is->is_login_pdu == NULL)
773 is->is_login_pdu = response;
776 ISCSI_SESSION_UNLOCK(is);
777 cv_signal(&is->is_login_cv);
783 * The handling routine is responsible for freeing the PDU
789 ISCSI_SESSION_UNLOCK(is);
794 ISCSI_SESSION_LOCK_ASSERT_NOT(is);
798 ISCSI_SESSION_UNLOCK(is);
803 ISCSI_SESSION_LOCK_ASSERT_NOT(is);
807 ISCSI_SESSION_UNLOCK(is);
811 ISCSI_SESSION_UNLOCK(is);
815 ISCSI_SESSION_UNLOCK(is);
819 ISCSI_SESSION_UNLOCK(is);
822 ISCSI_SESSION_WARN(is, "received PDU with unsupported "
825 iscsi_session_reconnect(is);
826 ISCSI_SESSION_UNLOCK(is);
834 struct iscsi_session *is;
836 is = CONN_SESSION(ic);
838 ISCSI_SESSION_WARN(is, "connection error; reconnecting");
839 iscsi_session_reconnect(is);
845 struct iscsi_session *is;
853 is = PDU_SESSION(response);
869 ISCSI_SESSION_WARN(is, "failed to allocate memory; "
872 iscsi_session_reconnect(is);
880 ISCSI_SESSION_WARN(is, "failed to allocate memory; "
884 iscsi_session_reconnect(is);
896 ISCSI_SESSION_WARN(is, "failed to allocate memory; "
901 iscsi_session_reconnect(is);
916 struct iscsi_session *is;
923 is = PDU_SESSION(response);
926 io = iscsi_outstanding_find(is, bhssr->bhssr_initiator_task_tag);
928 ISCSI_SESSION_WARN(is, "bad itt 0x%x", bhssr->bhssr_initiator_task_tag);
930 iscsi_session_reconnect(is);
931 ISCSI_SESSION_UNLOCK(is);
938 ISCSI_SESSION_WARN(is,
953 iscsi_session_reconnect(is);
954 ISCSI_SESSION_UNLOCK(is);
959 ISCSI_SESSION_WARN(is,
963 iscsi_session_reconnect(is);
964 ISCSI_SESSION_UNLOCK(is);
974 if (is->is_conn->ic_iser) {
979 ISCSI_SESSION_WARN(is, "overflow: target indicates %d", resid);
986 iscsi_outstanding_remove(is, io);
987 ISCSI_SESSION_UNLOCK(is);
990 ISCSI_SESSION_WARN(is, "service response 0x%x", bhssr->bhssr_response);
993 ISCSI_SESSION_DEBUG(is, "freezing devq");
1001 ISCSI_SESSION_DEBUG(is, "freezing devq");
1011 ISCSI_SESSION_WARN(is, "truncated data segment (%zd bytes)",
1015 ISCSI_SESSION_DEBUG(is, "freezing devq");
1023 ISCSI_SESSION_DEBUG(is, "sense_len %d, data len %zd",
1027 ISCSI_SESSION_WARN(is, "truncated data segment "
1032 ISCSI_SESSION_DEBUG(is, "freezing devq");
1037 ISCSI_SESSION_WARN(is, "oversize data segment "
1041 ISCSI_SESSION_DEBUG(is, "truncating sense from %d to %d",
1059 ISCSI_SESSION_WARN(is, "underflow mismatch: "
1076 struct iscsi_session *is;
1078 is = PDU_SESSION(response);
1081 io = iscsi_outstanding_find(is, bhstmr->bhstmr_initiator_task_tag);
1083 ISCSI_SESSION_WARN(is, "bad itt 0x%x",
1086 iscsi_session_reconnect(is);
1091 ISCSI_SESSION_WARN(is, "task response 0x%x",
1094 aio = iscsi_outstanding_find(is, io->io_referenced_task_tag);
1096 iscsi_session_terminate_task(is, aio, CAM_REQ_ABORTED);
1099 iscsi_outstanding_remove(is, io);
1126 struct iscsi_session *is;
1131 is = PDU_SESSION(response);
1133 io = iscsi_outstanding_find(is, bhsdi->bhsdi_initiator_task_tag);
1135 ISCSI_SESSION_WARN(is, "bad itt 0x%x", bhsdi->bhsdi_initiator_task_tag);
1137 iscsi_session_reconnect(is);
1138 ISCSI_SESSION_UNLOCK(is);
1143 ISCSI_SESSION_WARN(is, "received Data-In PDU with "
1147 iscsi_session_reconnect(is);
1148 ISCSI_SESSION_UNLOCK(is);
1160 ISCSI_SESSION_UNLOCK(is);
1171 ISCSI_SESSION_WARN(is, "data out of order; expected offset %zd, got %zd",
1174 iscsi_session_reconnect(is);
1175 ISCSI_SESSION_UNLOCK(is);
1183 ISCSI_SESSION_WARN(is, "oversize data segment (%zd bytes "
1184 "at offset %zd, buffer is %d)",
1187 iscsi_session_reconnect(is);
1188 ISCSI_SESSION_UNLOCK(is);
1196 iscsi_outstanding_remove(is, io);
1197 ISCSI_SESSION_UNLOCK(is);
1212 //ISCSI_SESSION_DEBUG(is, "got S flag; status 0x%x", bhsdi->bhsdi_status);
1218 ISCSI_SESSION_DEBUG(is, "freezing devq");
1230 ISCSI_SESSION_WARN(is, "underflow mismatch: "
1270 struct iscsi_session *is;
1279 is = PDU_SESSION(response);
1282 io = iscsi_outstanding_find(is, bhsr2t->bhsr2t_initiator_task_tag);
1284 ISCSI_SESSION_WARN(is, "bad itt 0x%x; reconnecting",
1287 iscsi_session_reconnect(is);
1294 ISCSI_SESSION_WARN(is, "received R2T for read command; reconnecting");
1296 iscsi_session_reconnect(is);
1306 ISCSI_SESSION_WARN(is, "target requested invalid offset "
1307 "%zd, buffer is %d; reconnecting", off, csio->dxfer_len);
1309 iscsi_session_reconnect(is);
1315 ISCSI_SESSION_WARN(is, "target requested invalid length "
1316 "%zd, buffer is %d; reconnecting", total_len, csio->dxfer_len);
1318 iscsi_session_reconnect(is);
1322 //ISCSI_SESSION_DEBUG(is, "r2t; off %zd, len %zd", off, total_len);
1324 if (is->is_conn->ic_hw_isomax != 0)
1325 max_send_data_segment_length = is->is_conn->ic_hw_isomax;
1328 is->is_conn->ic_max_send_data_segment_length;
1336 ISCSI_SESSION_WARN(is, "target requested invalid "
1337 "length/offset %zd, buffer is %d; reconnecting",
1340 iscsi_session_reconnect(is);
1347 iscsi_session_reconnect(is);
1363 ISCSI_SESSION_WARN(is, "failed to allocate memory; "
1367 iscsi_session_reconnect(is);
1372 is->is_conn->ic_max_send_data_segment_length);
1378 //ISCSI_SESSION_DEBUG(is, "setting F, off %zd", off);
1380 //ISCSI_SESSION_DEBUG(is, "not finished, off %zd", off);
1396 struct iscsi_session *is;
1398 is = PDU_SESSION(response);
1402 ISCSI_SESSION_WARN(is, "target requests logout; removing session");
1403 iscsi_session_logout(is);
1404 iscsi_session_terminate(is);
1407 ISCSI_SESSION_WARN(is, "target indicates it will drop the connection");
1410 ISCSI_SESSION_WARN(is, "target indicates it will drop the session");
1417 ISCSI_SESSION_WARN(is, "ignoring AsyncEvent %d", bhsam->bhsam_async_event);
1428 struct iscsi_session *is;
1430 is = PDU_SESSION(response);
1432 ISCSI_SESSION_WARN(is, "received Reject PDU, reason 0x%x; protocol error?",
1442 struct iscsi_session *is;
1447 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1448 ISCSI_SESSION_LOCK(is);
1449 if (is->is_conf.isc_enable == 0 &&
1450 is->is_conf.isc_discovery == 0) {
1451 ISCSI_SESSION_UNLOCK(is);
1454 if (is->is_waiting_for_iscsid)
1456 ISCSI_SESSION_UNLOCK(is);
1459 if (is == NULL) {
1476 is->is_waiting_for_iscsid = false;
1477 is->is_login_phase = true;
1478 is->is_reason[0] = '\0';
1479 ISCSI_SESSION_UNLOCK(is);
1481 request->idr_session_id = is->is_id;
1482 memcpy(&request->idr_isid, &is->is_isid,
1485 memcpy(&request->idr_conf, &is->is_conf,
1493 error = icl_limits(is->is_conf.isc_offload,
1494 is->is_conf.isc_iser, 0, &idl);
1496 ISCSI_SESSION_WARN(is, "icl_limits for "
1498 is->is_conf.isc_offload, error);
1523 struct iscsi_session *is;
1531 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1532 if (is->is_id == limits->idl_session_id)
1535 if (is == NULL) {
1540 error = icl_limits(is->is_conf.isc_offload, is->is_conf.isc_iser,
1544 ISCSI_SESSION_WARN(is, "icl_limits for offload \"%s\" "
1545 "failed with error %d", is->is_conf.isc_offload, error);
1564 struct iscsi_session *is;
1573 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1574 if (is->is_id == handoff->idh_session_id)
1577 if (is == NULL) {
1581 ISCSI_SESSION_LOCK(is);
1582 ic = is->is_conn;
1583 if (is->is_conf.isc_discovery || is->is_terminating) {
1584 ISCSI_SESSION_UNLOCK(is);
1588 if (is->is_connected) {
1594 ISCSI_SESSION_WARN(is, "handoff on already connected "
1596 ISCSI_SESSION_UNLOCK(is);
1601 strlcpy(is->is_target_alias, handoff->idh_target_alias,
1602 sizeof(is->is_target_alias));
1603 is->is_tsih = handoff->idh_tsih;
1604 is->is_statsn = handoff->idh_statsn;
1605 is->is_protocol_level = handoff->idh_protocol_level;
1606 is->is_initial_r2t = handoff->idh_initial_r2t;
1607 is->is_immediate_data = handoff->idh_immediate_data;
1613 is->is_max_burst_length = handoff->idh_max_burst_length;
1614 is->is_first_burst_length = handoff->idh_first_burst_length;
1626 is->is_cmdsn = 0;
1627 is->is_expcmdsn = 0;
1628 is->is_maxcmdsn = 0;
1629 is->is_waiting_for_iscsid = false;
1630 is->is_login_phase = false;
1631 is->is_timeout = 0;
1632 is->is_ping_timeout = is->is_conf.isc_ping_timeout;
1633 if (is->is_ping_timeout < 0)
1634 is->is_ping_timeout = ping_timeout;
1635 is->is_login_timeout = is->is_conf.isc_login_timeout;
1636 if (is->is_login_timeout < 0)
1637 is->is_login_timeout = login_timeout;
1638 is->is_connected = true;
1639 is->is_reason[0] = '\0';
1641 ISCSI_SESSION_UNLOCK(is);
1651 iscsi_session_terminate(is);
1657 if (is->is_sim != NULL) {
1659 * When reconnecting, there already is SIM allocated for the session.
1661 KASSERT(is->is_simq_frozen, ("reconnect without frozen simq"));
1662 ISCSI_SESSION_LOCK(is);
1663 ISCSI_SESSION_DEBUG(is, "releasing");
1664 is->is_simq_frozen = false;
1665 xpt_release_simq(is->is_sim, 1);
1666 ISCSI_SESSION_UNLOCK(is);
1669 ISCSI_SESSION_LOCK(is);
1670 is->is_devq = cam_simq_alloc(ic->ic_maxtags);
1671 if (is->is_devq == NULL) {
1672 ISCSI_SESSION_UNLOCK(is);
1673 ISCSI_SESSION_WARN(is, "failed to allocate simq");
1674 iscsi_session_terminate(is);
1678 is->is_sim = cam_sim_alloc(iscsi_action, NULL, "iscsi",
1679 is, is->is_id /* unit */, &is->is_lock,
1680 1, ic->ic_maxtags, is->is_devq);
1681 if (is->is_sim == NULL) {
1682 ISCSI_SESSION_UNLOCK(is);
1683 ISCSI_SESSION_WARN(is, "failed to allocate SIM");
1684 cam_simq_free(is->is_devq);
1685 iscsi_session_terminate(is);
1689 if (xpt_bus_register(is->is_sim, NULL, 0) != 0) {
1690 ISCSI_SESSION_UNLOCK(is);
1691 ISCSI_SESSION_WARN(is, "failed to register bus");
1692 iscsi_session_terminate(is);
1696 error = xpt_create_path(&is->is_path, /*periph*/NULL,
1697 cam_sim_path(is->is_sim), CAM_TARGET_WILDCARD,
1700 ISCSI_SESSION_UNLOCK(is);
1701 ISCSI_SESSION_WARN(is, "failed to create path");
1702 iscsi_session_terminate(is);
1705 ISCSI_SESSION_UNLOCK(is);
1715 struct iscsi_session *is;
1719 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1720 if (is->is_id == fail->idf_session_id)
1723 if (is == NULL) {
1727 ISCSI_SESSION_LOCK(is);
1728 ISCSI_SESSION_DEBUG(is, "iscsid(8) failed: %s",
1730 strlcpy(is->is_reason, fail->idf_reason, sizeof(is->is_reason));
1731 //is->is_waiting_for_iscsid = false;
1732 //is->is_login_phase = true;
1733 //iscsi_session_reconnect(is);
1734 ISCSI_SESSION_UNLOCK(is);
1745 struct iscsi_session *is;
1750 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1751 if (is->is_id == idc->idc_session_id)
1754 if (is == NULL) {
1763 ISCSI_SESSION_WARN(is,
1772 ISCSI_SESSION_WARN(is, "getsockaddr failed with error %d",
1778 ISCSI_SESSION_LOCK(is);
1779 is->is_statsn = 0;
1780 is->is_cmdsn = 0;
1781 is->is_expcmdsn = 0;
1782 is->is_maxcmdsn = 0;
1783 is->is_waiting_for_iscsid = false;
1784 is->is_login_phase = true;
1785 is->is_timeout = 0;
1786 ISCSI_SESSION_UNLOCK(is);
1788 error = icl_conn_connect(is->is_conn, idc->idc_domain,
1796 is->is_conn->ic_header_crc32c = false;
1797 is->is_conn->ic_data_crc32c = false;
1806 struct iscsi_session *is;
1813 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1814 if (is->is_id == ids->ids_session_id)
1817 if (is == NULL) {
1823 if (is->is_login_phase == false)
1826 if (is->is_terminating || is->is_reconnecting)
1830 if (datalen > is->is_conn->ic_max_send_data_segment_length)
1841 ip = icl_pdu_new(is->is_conn, M_WAITOK);
1857 struct iscsi_session *is;
1863 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1864 if (is->is_id == idr->idr_session_id)
1867 if (is == NULL) {
1873 if (is->is_login_phase == false)
1876 ISCSI_SESSION_LOCK(is);
1877 while (is->is_login_pdu == NULL &&
1878 is->is_terminating == false &&
1879 is->is_reconnecting == false) {
1880 error = cv_wait_sig(&is->is_login_cv, &is->is_lock);
1882 ISCSI_SESSION_UNLOCK(is);
1886 if (is->is_terminating || is->is_reconnecting) {
1887 ISCSI_SESSION_UNLOCK(is);
1890 ip = is->is_login_pdu;
1891 is->is_login_pdu = NULL;
1892 ISCSI_SESSION_UNLOCK(is);
1919 * XXX: This is not particularly secure. We should
1964 struct iscsi_session *is;
1973 is = malloc(sizeof(*is), M_ISCSI, M_ZERO | M_WAITOK);
1974 memcpy(&is->is_conf, &isa->isa_conf, sizeof(is->is_conf));
1982 if (!!is->is_conf.isc_discovery !=
1986 if (strcmp(is->is_conf.isc_target_addr,
1990 if (is->is_conf.isc_discovery == 0 &&
1991 strcmp(is->is_conf.isc_target,
1996 free(is, M_ISCSI);
2000 is->is_conn = icl_new_conn(is->is_conf.isc_offload,
2001 is->is_conf.isc_iser, "iscsi", &is->is_lock);
2002 if (is->is_conn == NULL) {
2004 free(is, M_ISCSI);
2007 is->is_conn->ic_receive = iscsi_receive_callback;
2008 is->is_conn->ic_error = iscsi_error_callback;
2009 is->is_conn->ic_prv0 = is;
2010 TAILQ_INIT(&is->is_outstanding);
2011 STAILQ_INIT(&is->is_postponed);
2012 mtx_init(&is->is_lock, "iscsi_lock", NULL, MTX_DEF);
2013 cv_init(&is->is_maintenance_cv, "iscsi_mt");
2015 cv_init(&is->is_login_cv, "iscsi_login");
2025 is->is_conn->ic_max_recv_data_segment_length = 8192;
2026 is->is_conn->ic_max_send_data_segment_length = 8192;
2027 is->is_max_burst_length = 262144;
2028 is->is_first_burst_length = 65536;
2030 is->is_softc = sc;
2032 is->is_id = sc->sc_last_session_id;
2033 is->is_isid[0] = 0x80; /* RFC 3720, 10.12.5: 10b, "Random" ISID. */
2034 arc4rand(&is->is_isid[1], 5, 0);
2035 is->is_tsih = 0;
2036 callout_init(&is->is_callout, 1);
2038 error = kthread_add(iscsi_maintenance_thread, is, NULL, NULL, 0, 0, "iscsimt");
2040 ISCSI_SESSION_WARN(is, "kthread_add(9) failed with error %d", error);
2044 is->is_ping_timeout = is->is_conf.isc_ping_timeout;
2045 if (is->is_ping_timeout < 0)
2046 is->is_ping_timeout = ping_timeout;
2047 is->is_login_timeout = is->is_conf.isc_login_timeout;
2048 if (is->is_login_timeout < 0)
2049 is->is_login_timeout = login_timeout;
2053 callout_reset_sbt(&is->is_callout, sbt, pr, iscsi_callout, is, 0);
2054 TAILQ_INSERT_TAIL(&sc->sc_sessions, is, is_next);
2056 ISCSI_SESSION_LOCK(is);
2058 * Don't notify iscsid(8) if the session is disabled and it's not
2061 if (is->is_conf.isc_enable == 0 && is->is_conf.isc_discovery == 0) {
2062 ISCSI_SESSION_UNLOCK(is);
2067 is->is_waiting_for_iscsid = true;
2068 strlcpy(is->is_reason, "Waiting for iscsid(8)", sizeof(is->is_reason));
2069 ISCSI_SESSION_UNLOCK(is);
2095 struct iscsi_session *is, *tmp;
2101 TAILQ_FOREACH_SAFE(is, &sc->sc_sessions, is_next, tmp) {
2102 ISCSI_SESSION_LOCK(is);
2103 if (iscsi_session_conf_matches(is->is_id, &is->is_conf,
2106 iscsi_session_logout(is);
2107 iscsi_session_terminate(is);
2109 ISCSI_SESSION_UNLOCK(is);
2124 struct iscsi_session *is;
2128 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
2134 memcpy(&iss.iss_conf, &is->is_conf, sizeof(iss.iss_conf));
2135 iss.iss_id = is->is_id;
2136 strlcpy(iss.iss_target_alias, is->is_target_alias, sizeof(iss.iss_target_alias));
2137 strlcpy(iss.iss_reason, is->is_reason, sizeof(iss.iss_reason));
2138 strlcpy(iss.iss_offload, is->is_conn->ic_offload, sizeof(iss.iss_offload));
2140 if (is->is_conn->ic_header_crc32c)
2145 if (is->is_conn->ic_data_crc32c)
2151 is->is_conn->ic_max_send_data_segment_length;
2153 is->is_conn->ic_max_recv_data_segment_length;
2154 iss.iss_max_burst_length = is->is_max_burst_length;
2155 iss.iss_first_burst_length = is->is_first_burst_length;
2156 iss.iss_immediate_data = is->is_immediate_data;
2157 iss.iss_connected = is->is_connected;
2177 struct iscsi_session *is;
2185 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
2186 ISCSI_SESSION_LOCK(is);
2187 if (is->is_id == ism->ism_session_id) {
2191 ISCSI_SESSION_UNLOCK(is);
2193 if (is == NULL) {
2202 if (is == is2)
2218 ISCSI_SESSION_UNLOCK(is);
2225 memcpy(&is->is_conf, &ism->ism_conf, sizeof(is->is_conf));
2226 ISCSI_SESSION_UNLOCK(is);
2228 iscsi_session_reconnect(is);
2288 iscsi_outstanding_find(struct iscsi_session *is, uint32_t initiator_task_tag)
2292 ISCSI_SESSION_LOCK_ASSERT(is);
2294 TAILQ_FOREACH(io, &is->is_outstanding, io_next) {
2302 iscsi_outstanding_find_ccb(struct iscsi_session *is, union ccb *ccb)
2306 ISCSI_SESSION_LOCK_ASSERT(is);
2308 TAILQ_FOREACH(io, &is->is_outstanding, io_next) {
2316 iscsi_outstanding_add(struct iscsi_session *is, struct icl_pdu *request,
2322 ISCSI_SESSION_LOCK_ASSERT(is);
2326 ISCSI_SESSION_WARN(is, "failed to allocate %zd bytes",
2331 error = icl_conn_task_setup(is->is_conn, request, &ccb->csio,
2334 ISCSI_SESSION_WARN(is,
2340 KASSERT(iscsi_outstanding_find(is, *initiator_task_tagp) == NULL,
2345 TAILQ_INSERT_TAIL(&is->is_outstanding, io, io_next);
2350 iscsi_outstanding_remove(struct iscsi_session *is, struct iscsi_outstanding *io)
2353 ISCSI_SESSION_LOCK_ASSERT(is);
2355 icl_conn_task_done(is->is_conn, io->io_icl_prv);
2356 TAILQ_REMOVE(&is->is_outstanding, io, io_next);
2361 iscsi_action_abort(struct iscsi_session *is, union ccb *ccb)
2369 ISCSI_SESSION_LOCK_ASSERT(is);
2372 KASSERT(is->is_login_phase == false, ("%s called during Login Phase", __func__));
2374 if (is->is_login_phase) {
2381 aio = iscsi_outstanding_find_ccb(is, cab->abort_ccb);
2388 request = icl_pdu_new(is->is_conn, M_NOWAIT);
2395 initiator_task_tag = is->is_initiator_task_tag++;
2397 initiator_task_tag = is->is_initiator_task_tag++;
2399 io = iscsi_outstanding_add(is, request, NULL, &initiator_task_tag);
2419 iscsi_action_scsiio(struct iscsi_session *is, union ccb *ccb)
2429 ISCSI_SESSION_LOCK_ASSERT(is);
2432 KASSERT(is->is_login_phase == false, ("%s called during Login Phase", __func__));
2434 if (is->is_login_phase) {
2435 ISCSI_SESSION_DEBUG(is, "called during login phase");
2438 ISCSI_SESSION_DEBUG(is, "freezing devq");
2446 request = icl_pdu_new(is->is_conn, M_NOWAIT);
2450 ISCSI_SESSION_DEBUG(is, "freezing devq");
2457 initiator_task_tag = is->is_initiator_task_tag++;
2459 initiator_task_tag = is->is_initiator_task_tag++;
2461 io = iscsi_outstanding_add(is, request, ccb, &initiator_task_tag);
2466 ISCSI_SESSION_DEBUG(is, "freezing devq");
2505 if (is->is_protocol_level >= 2) {
2521 if (is->is_immediate_data &&
2524 //ISCSI_SESSION_DEBUG(is, "adding %zd of immediate data", len);
2525 if (len > is->is_first_burst_length) {
2526 ISCSI_SESSION_DEBUG(is, "len %zd -> %d", len, is->is_first_burst_length);
2527 len = is->is_first_burst_length;
2529 if (len > is->is_conn->ic_max_send_data_segment_length) {
2530 ISCSI_SESSION_DEBUG(is, "len %zd -> %d", len,
2531 is->is_conn->ic_max_send_data_segment_length);
2532 len = is->is_conn->ic_max_send_data_segment_length;
2538 iscsi_outstanding_remove(is, io);
2542 ISCSI_SESSION_DEBUG(is, "freezing devq");
2555 struct iscsi_session *is;
2557 is = cam_sim_softc(sim);
2559 ISCSI_SESSION_LOCK_ASSERT(is);
2561 if (is->is_terminating ||
2562 (is->is_connected == false && fail_on_disconnection)) {
2571 if (is->is_simq_frozen == true) {
2574 /* Don't freeze the devq - the SIM queue is already frozen. */
2592 if (is->is_conn == NULL)
2594 else if (is->is_conn->ic_unmapped)
2599 * Note that the variable below is only relevant for targets
2646 ISCSI_SESSION_DEBUG(is, "faking success for reset, abort, or term_io");
2651 iscsi_action_abort(is, ccb);
2654 iscsi_action_scsiio(is, ccb);
2658 ISCSI_SESSION_DEBUG(is, "got unsupported code 0x%x", ccb->ccb_h.func_code);
2669 struct iscsi_session *is;
2672 TAILQ_FOREACH(is, &sc->sc_sessions, is_next)
2673 iscsi_session_terminate(is);
2685 struct iscsi_session *is;
2705 TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
2706 ISCSI_SESSION_LOCK(is);
2707 if (!is->is_connected) {
2708 ISCSI_SESSION_DEBUG(is, "force failing disconnected session early");
2709 iscsi_session_reconnect(is);
2711 ISCSI_SESSION_UNLOCK(is);
2752 * CAM shutdown - otherwise when rebooting with an iSCSI session that is