iscsid: simplify qtask handling

We only have qtasks for login/sync or logout. There is no need to pass
it around when we can just have 2 pointers for the 2 types. We can then
quickly check if a login or logout is in progress and in the future
kill a running login when we get a logout request.

Signed-off-by: Mike Christie <michael.christie@oracle.com>

2 files changed, 93 insertions, 136 deletions

diff --git a/usr/initiator.c b/usr/initiator.c
index 503ccba..c42e356 100644
--- a/usr/initiator.c
+++ b/usr/initiator.c
@@ -263,7 +263,7 @@ __session_conn_create(iscsi_session_t *session, int cid)
 
 	conn->state = ISCSI_CONN_STATE_FREE;
 	conn->session = session;
-	actor_init(&conn->login_timer, iscsi_login_timedout, NULL);
+	actor_init(&conn->login_timer, iscsi_login_timedout, conn);
 	/*
 	 * TODO: we must export the socket_fd/transport_eph from sysfs
 	 * so if iscsid is resyncing up we can pick that up and cleanup up
@@ -351,7 +351,6 @@ __session_create(node_rec_t *rec, struct iscsi_transport *t, int *rc)
 
 	INIT_LIST_HEAD(&session->list);
 	session->t = t;
-	session->reopen_qtask.mgmt_ipc_fd = -1;
 	session->id = INVALID_SESSION_ID;
 	session->use_ipc = 1;
 
@@ -462,10 +461,18 @@ conn_delete_timers(iscsi_conn_t *conn)
 }
 
 static int 
-session_conn_shutdown(iscsi_conn_t *conn, queue_task_t *qtask,
-		      int err)
+session_conn_shutdown(iscsi_conn_t *conn, int err)
 {
 	iscsi_session_t *session = conn->session;
+	queue_task_t *qtask = NULL;
+
+	if (conn->login_qtask) {
+		qtask = conn->login_qtask;
+		conn->login_qtask = NULL;
+	} else if (conn->logout_qtask) {
+		qtask = conn->logout_qtask;
+		conn->logout_qtask = NULL;
+	}
 
 	conn_debug(2, conn, "disconnect conn");
 	/* this will check for a valid interconnect connection */
@@ -514,27 +521,26 @@ cleanup:
 		    session->nrec.conn[conn->id].port,
 		    session->nrec.iface.name);
 
-	mgmt_ipc_write_rsp(qtask, err);
+	if (qtask)
+		mgmt_ipc_write_rsp(qtask, err);
 	conn_delete_timers(conn);
 	__session_destroy(session);
 	return ISCSI_SUCCESS;
 }
 
 static void
-queue_delayed_reopen(queue_task_t *qtask, int delay)
+queue_delayed_reopen(struct iscsi_conn *conn, int delay)
 {
-	iscsi_conn_t *conn = qtask->conn;
-
 	conn_debug(4, conn, "Requeue reopen attempt in %d secs", delay);
 
 	/*
  	 * iscsi_login_eh can handle the login resched as
  	 * if it were login time out
  	 */
-	actor_timer_mod(&conn->login_timer, delay, qtask);
+	actor_timer_mod(&conn->login_timer, delay, conn);
 }
 
-static int iscsi_conn_connect(struct iscsi_conn *conn, queue_task_t *qtask)
+static int iscsi_conn_connect(struct iscsi_conn *conn)
 {
 	struct iscsi_ev_context *ev_context;
 	int rc;
@@ -546,7 +552,6 @@ static int iscsi_conn_connect(struct iscsi_conn *conn, queue_task_t *qtask)
 			  "context for recv.");
 		return ENOMEM;
 	}
-	ev_context->data = qtask;
 
 	rc = conn->session->t->template->ep_connect(conn, 1);
 	if (rc < 0 && errno != EINPROGRESS) {
@@ -566,13 +571,12 @@ static int iscsi_conn_connect(struct iscsi_conn *conn, queue_task_t *qtask)
 	iscsi_sched_ev_context(ev_context, conn, 0, EV_CONN_POLL);
 	conn_debug(3, conn, "Setting login timer %p timeout %d", &conn->login_timer,
 		  conn->login_timeout);
-	actor_timer_mod(&conn->login_timer, conn->login_timeout, qtask);
+	actor_timer_mod(&conn->login_timer, conn->login_timeout, conn);
 	return 0;
 }
 
 static void
-__session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop,
-		      int redirected)
+__session_conn_reopen(iscsi_conn_t *conn, int do_stop, int redirected)
 {
 	iscsi_session_t *session = conn->session;
 	uint32_t delay;
@@ -580,8 +584,6 @@ __session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop,
 	log_debug(1, "re-opening session %d (reopen_cnt %d)", session->id,
 			session->reopen_cnt);
 
-	qtask->conn = conn;
-
 	/* flush stale polls or errors queued */
 	iscsi_flush_context_pool(session);
 	conn_delete_timers(conn);
@@ -616,7 +618,7 @@ __session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop,
 				 &conn->session->nrec.iface) != 0)
 		goto queue_reopen;
 
-	if (iscsi_conn_connect(conn, qtask)) {
+	if (iscsi_conn_connect(conn)) {
 		delay = ISCSI_CONN_ERR_REOPEN_DELAY;
 		goto queue_reopen;
 	}
@@ -624,11 +626,11 @@ __session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop,
 
 queue_reopen:
 	conn_debug(4, conn, "Waiting %u seconds before trying to reconnect.", delay);
-	queue_delayed_reopen(qtask, delay);
+	queue_delayed_reopen(conn, delay);
 }
 
 static void
-session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop)
+session_conn_reopen(iscsi_conn_t *conn, int do_stop)
 {
 	/*
 	 * If we were temporarily redirected, we need to fall back to
@@ -638,7 +640,7 @@ session_conn_reopen(iscsi_conn_t *conn, queue_task_t *qtask, int do_stop)
 	memset(&conn->saddr, 0, sizeof(struct sockaddr_storage));
 	conn->saddr = conn->failback_saddr;
 
-	__session_conn_reopen(conn, qtask, do_stop, 0);
+	__session_conn_reopen(conn, do_stop, 0);
 }
 
 static int iscsi_retry_initial_login(struct iscsi_conn *conn)
@@ -683,13 +685,13 @@ static int iscsi_login_is_fatal_err(int err)
 	return 0;
 }
 
-static void iscsi_login_eh(struct iscsi_conn *conn, struct queue_task *qtask,
-			   int err)
+static void iscsi_login_eh(struct iscsi_conn *conn, int err)
 {
 	struct iscsi_session *session = conn->session;
 	int stop_flag = 0;
 
-	conn_debug(3, conn, "iscsi_login_eh");
+	conn_debug(3, conn, "iscsi_login_eh state %d/%d", session->r_stage,
+		   conn->state);
 	/*
 	 * Flush polls and other events
 	 */
@@ -705,12 +707,12 @@ static void iscsi_login_eh(struct iscsi_conn *conn, struct queue_task *qtask,
 			 * clean connection. write ipc rsp or retry */
 			if (iscsi_login_is_fatal_err(err) ||
 			    !iscsi_retry_initial_login(conn))
-				session_conn_shutdown(conn, qtask, err);
+				session_conn_shutdown(conn, err);
 			else {
 				stop_flag = (session->id < INVALID_SESSION_ID) ? STOP_CONN_TERM : 0;
 				conn_debug(6, conn, "connection %p socket_fd: %d stop_flag: %d\n",
 					  conn, conn->socket_fd, stop_flag);
-				session_conn_reopen(conn, qtask, stop_flag);
+				session_conn_reopen(conn, stop_flag);
 			}
 			break;
 		case R_STAGE_SESSION_REDIRECT:
@@ -720,9 +722,9 @@ static void iscsi_login_eh(struct iscsi_conn *conn, struct queue_task *qtask,
 			 * clean connection. write ipc rsp or retry */
 			if (iscsi_login_is_fatal_err(err) ||
 			    !iscsi_retry_initial_login(conn))
-				session_conn_shutdown(conn, qtask, err);
+				session_conn_shutdown(conn, err);
 			else
-				session_conn_reopen(conn, qtask, 0);
+				session_conn_reopen(conn, 0);
 			break;
 		case R_STAGE_SESSION_REOPEN:
 			conn_debug(6, conn, "login failed ISCSI_CONN_STATE_XPT_WAIT/"
@@ -732,14 +734,14 @@ static void iscsi_login_eh(struct iscsi_conn *conn, struct queue_task *qtask,
 			    (session->reopen_cnt > session->reopen_max)) {
 				log_info("Giving up on session %d after %d retries", 
 						session->id, session->reopen_max);
-				session_conn_shutdown(conn, qtask, err);
+				session_conn_shutdown(conn, err);
 				break;
 			}
 			/* timeout during reopen connect. try again */
-			session_conn_reopen(conn, qtask, 0);
+			session_conn_reopen(conn, 0);
 			break;
 		case R_STAGE_SESSION_CLEANUP:
-			session_conn_shutdown(conn, qtask, err);
+			session_conn_shutdown(conn, err);
 			break;
 		default:
 			break;
@@ -760,20 +762,18 @@ static void iscsi_login_eh(struct iscsi_conn *conn, struct queue_task *qtask,
 			 */
 			if (iscsi_login_is_fatal_err(err) ||
 			    !iscsi_retry_initial_login(conn))
-				session_conn_shutdown(conn, qtask, err);
+				session_conn_shutdown(conn, err);
 			else
-				session_conn_reopen(conn, qtask,
-						    STOP_CONN_RECOVER);
+				session_conn_reopen(conn, STOP_CONN_RECOVER);
 			break;
 		case R_STAGE_SESSION_REOPEN:
 			conn_debug(6, conn, "login failed ISCSI_CONN_STATE_IN_LOGIN/"
 				  "R_STAGE_SESSION_REOPEN %d",
 				  session->reopen_cnt);
-			session_conn_reopen(conn, qtask, STOP_CONN_RECOVER);
+			session_conn_reopen(conn, STOP_CONN_RECOVER);
 			break;
 		case R_STAGE_SESSION_CLEANUP:
-			session_conn_shutdown(conn, qtask,
-					      ISCSI_ERR_PDU_TIMEOUT);
+			session_conn_shutdown(conn, ISCSI_ERR_PDU_TIMEOUT);
 			break;
 		default:
 			break;
@@ -797,7 +797,7 @@ __conn_error_handle(iscsi_session_t *session, iscsi_conn_t *conn)
 	 * just cleanup and return to the user.
 	 */
 	if (conn->logout_qtask) {
-		session_conn_shutdown(conn, conn->logout_qtask, ISCSI_SUCCESS);
+		session_conn_shutdown(conn, ISCSI_SUCCESS);
 		return;
 	}
 
@@ -834,13 +834,7 @@ __conn_error_handle(iscsi_session_t *session, iscsi_conn_t *conn)
 		break;
 	case ISCSI_CONN_STATE_IN_LOGIN:
 		if (session->r_stage == R_STAGE_SESSION_REOPEN) {
-			queue_task_t *qtask;
-
-			if (session->notify_qtask)
-				qtask = session->notify_qtask;
-			else
-				qtask = &session->reopen_qtask;
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_TRANS);
+			iscsi_login_eh(conn, ISCSI_ERR_TRANS);
 			return;
 		}
 		conn_debug(1, conn, "ignoring conn error in login. "
@@ -860,8 +854,7 @@ __conn_error_handle(iscsi_session_t *session, iscsi_conn_t *conn)
 	}
 
 	if (session->r_stage == R_STAGE_SESSION_REOPEN) {
-		session_conn_reopen(conn, &session->reopen_qtask,
-				    STOP_CONN_RECOVER);
+		session_conn_reopen(conn, STOP_CONN_RECOVER);
 		return;
 	}
 }
@@ -882,7 +875,7 @@ static void session_conn_error(void *data)
 
 	switch (error) {
 	case ISCSI_ERR_INVALID_HOST:
-		if (session_conn_shutdown(conn, NULL, ISCSI_SUCCESS))
+		if (session_conn_shutdown(conn, ISCSI_SUCCESS))
 			log_error("BUG: Could not shutdown session:%d.", sid);
 		break;
 	default:
@@ -892,18 +885,17 @@ static void session_conn_error(void *data)
 
 static void iscsi_login_timedout(void *data)
 {
-	struct queue_task *qtask = data;
-	struct iscsi_conn *conn = qtask->conn;
+	struct iscsi_conn *conn = data;
 
 	switch (conn->state) {
 	case ISCSI_CONN_STATE_XPT_WAIT:
-		iscsi_login_eh(conn, qtask, ISCSI_ERR_TRANS_TIMEOUT);
+		iscsi_login_eh(conn, ISCSI_ERR_TRANS_TIMEOUT);
 		break;
 	case ISCSI_CONN_STATE_IN_LOGIN:
-		iscsi_login_eh(conn, qtask, ISCSI_ERR_PDU_TIMEOUT);
+		iscsi_login_eh(conn, ISCSI_ERR_PDU_TIMEOUT);
 		break;
 	default:
-		iscsi_login_eh(conn, qtask, ISCSI_ERR_INTERNAL);
+		iscsi_login_eh(conn, ISCSI_ERR_INTERNAL);
 		break;
 	}
 }
@@ -911,14 +903,13 @@ static void iscsi_login_timedout(void *data)
 static void iscsi_login_redirect(iscsi_conn_t *conn)
 {
 	iscsi_session_t *session = conn->session;
-	iscsi_login_context_t *c = &conn->login_context;
 
 	conn_debug(3, conn, "login redirect ...");
 
 	if (session->r_stage == R_STAGE_NO_CHANGE)
 		session->r_stage = R_STAGE_SESSION_REDIRECT;
 
-	__session_conn_reopen(conn, c->qtask, STOP_CONN_RECOVER, 1);
+	__session_conn_reopen(conn, STOP_CONN_RECOVER, 1);
 }
 
 static int
@@ -1031,13 +1022,12 @@ static void
 setup_full_feature_phase(iscsi_conn_t *conn)
 {
 	iscsi_session_t *session = conn->session;
-	iscsi_login_context_t *c = &conn->login_context;
 	int rc;
 
 	actor_delete(&conn->login_timer);
 
 	if (iscsi_session_set_neg_params(conn)) {
-		iscsi_login_eh(conn, c->qtask, ISCSI_ERR_LOGIN);
+		iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 		return;
 	}
 
@@ -1045,7 +1035,7 @@ setup_full_feature_phase(iscsi_conn_t *conn)
 			    &rc) || rc) {
 		log_error("can't start connection %d:%d retcode %d (%d)",
 			  session->id, conn->id, rc, errno);
-		iscsi_login_eh(conn, c->qtask, ISCSI_ERR_INTERNAL);
+		iscsi_login_eh(conn, ISCSI_ERR_INTERNAL);
 		return;
 	}
 
@@ -1057,7 +1047,8 @@ setup_full_feature_phase(iscsi_conn_t *conn)
 		 * don't want to re-scan it on recovery.
 		 */
 		if (conn->id == 0)
-			session_scan_host(session, session->hostno, c->qtask);
+			session_scan_host(session, session->hostno,
+					  conn->login_qtask);
 
 		log_warning("Connection%d:%d to [target: %s, portal: %s,%d] "
 			    "through [iface: %s] is operational now",
@@ -1066,14 +1057,13 @@ setup_full_feature_phase(iscsi_conn_t *conn)
 			    session->nrec.conn[conn->id].port,
 			    session->nrec.iface.name);
 	} else {
-		session->notify_qtask = NULL;
-
 		session_online_devs(session->hostno, session->id);
-		mgmt_ipc_write_rsp(c->qtask, ISCSI_SUCCESS);
+		mgmt_ipc_write_rsp(conn->login_qtask, ISCSI_SUCCESS);
 		log_warning("connection%d:%d is operational after recovery "
 			    "(%d attempts)", session->id, conn->id,
 			     session->reopen_cnt);
 	}
+	conn->login_qtask = NULL;
 
 	/*
 	 * reset ERL=0 reopen counter
@@ -1153,7 +1143,7 @@ static void iscsi_stop(void *data)
 			return;
 	}
 
-	rc = session_conn_shutdown(conn, conn->logout_qtask, ISCSI_SUCCESS);
+	rc = session_conn_shutdown(conn, ISCSI_SUCCESS);
 	if (rc)
 		log_error("BUG: Could not shutdown session:%d.", sid);
 }
@@ -1292,7 +1282,7 @@ static void iscsi_recv_login_rsp(struct iscsi_conn *conn)
 		/* more nego. needed! */
 		conn->state = ISCSI_CONN_STATE_IN_LOGIN;
 		if (iscsi_login_req(session, c)) {
-			iscsi_login_eh(conn, c->qtask, ISCSI_ERR_LOGIN);
+			iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 			return;
 		}
 	} else
@@ -1301,12 +1291,12 @@ static void iscsi_recv_login_rsp(struct iscsi_conn *conn)
 	return;
 retry:
 	/* retry if not initial login or initial login has not timed out */
-	iscsi_login_eh(conn, c->qtask, ISCSI_ERR_LOGIN);
+	iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 	return;
 failed:
 	/* force failure if initial login */
 	session->reopen_cnt = session->nrec.session.initial_login_retry_max;
-	iscsi_login_eh(conn, c->qtask, err);
+	iscsi_login_eh(conn, err);
 	return;
 }
 
@@ -1481,23 +1471,22 @@ retry_create:
 static void setup_offload_login_phase(iscsi_conn_t *conn)
 {
 	iscsi_session_t *session = conn->session;
-	iscsi_login_context_t *c = &conn->login_context;
 	int rc;
 
 	actor_delete(&conn->login_timer);
 
 	if (iscsi_session_set_params(conn)) {
-		iscsi_login_eh(conn, c->qtask, ISCSI_ERR_LOGIN);
+		iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 		return;
 	}
 
 	if (iscsi_session_set_neg_params(conn)) {
-		iscsi_login_eh(conn, c->qtask, ISCSI_ERR_LOGIN);
+		iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 		return;
 	}
 
 	if (iscsi_host_set_params(session)) {
-		iscsi_login_eh(conn, c->qtask, ISCSI_ERR_LOGIN);
+		iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 		return;
 	}
 
@@ -1506,17 +1495,14 @@ static void setup_offload_login_phase(iscsi_conn_t *conn)
 			    &rc) || rc) {
 		if (rc == -EEXIST) {
 			conn_error(conn, "Session already exists.");
-			session_conn_shutdown(conn, c->qtask,
-					      ISCSI_ERR_SESS_EXISTS);
+			session_conn_shutdown(conn, ISCSI_ERR_SESS_EXISTS);
 		} else {
 			log_error("can't start connection %d:%d retcode (%d)",
 				  session->id, conn->id, rc);
-			iscsi_login_eh(conn, c->qtask, ISCSI_ERR_INTERNAL);
+			iscsi_login_eh(conn, ISCSI_ERR_INTERNAL);
 		}
 		return;
 	}
-
-	session->notify_qtask = c->qtask;
 }
 
 
@@ -1526,7 +1512,6 @@ static void session_conn_poll(void *data)
 	iscsi_conn_t *conn = ev_context->conn;
 	struct iscsi_session *session = conn->session;
 	int err = ISCSI_SUCCESS;
-	queue_task_t *qtask = ev_context->data;
 	iscsi_login_context_t *c = &conn->login_context;
 	int rc;
 
@@ -1543,10 +1528,9 @@ static void session_conn_poll(void *data)
 			/* while polling the recv pool should be full */
 			conn_error(conn, "BUG: session_conn_poll could not get conn "
 				  "context.");
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_INTERNAL);
+			iscsi_login_eh(conn, ISCSI_ERR_INTERNAL);
 			return;
 		}
-		ev_context->data = qtask;
 		/* not connected yet, check later */
 		iscsi_sched_ev_context(ev_context, conn, 1, EV_CONN_POLL);
 	} else if (rc > 0) {
@@ -1592,13 +1576,12 @@ static void session_conn_poll(void *data)
 			log_error("can't bind conn %d:%d to session %d, "
 				  "retcode %d (%d)", session->id, conn->id,
 				   session->id, rc, errno);
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_LOGIN);
+			iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 			return;
 		}
 		log_debug(3, "bound iSCSI connection %d:%d to session %d",
 			  session->id, conn->id, session->id);
 
-		c->qtask = qtask;
 		c->cid = conn->id;
 		c->buffer = conn->data;
 		c->bufsize = sizeof(conn->data);
@@ -1611,34 +1594,34 @@ static void session_conn_poll(void *data)
 		}
 
 		if (iscsi_session_set_params(conn)) {
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_LOGIN);
+			iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 			return;
 		}
 
 		if (iscsi_host_set_params(session)) {
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_LOGIN);
+			iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 			return;
 		}
 
 		if (iscsi_login_begin(session, c)) {
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_LOGIN);
+			iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 			return;
 		}
 
 		conn->state = ISCSI_CONN_STATE_IN_LOGIN;
 		if (iscsi_login_req(session, c)) {
-			iscsi_login_eh(conn, qtask, ISCSI_ERR_LOGIN);
+			iscsi_login_eh(conn, ISCSI_ERR_LOGIN);
 			return;
 		}
 	} else {
 		conn_debug(4, conn, "poll error %d", rc);
-		queue_delayed_reopen(qtask, ISCSI_CONN_ERR_REOPEN_DELAY);
+		queue_delayed_reopen(conn, ISCSI_CONN_ERR_REOPEN_DELAY);
 	}
 
 	return;
 
 cleanup:
-	session_conn_shutdown(conn, qtask, err);
+	session_conn_shutdown(conn, err);
 }
 
 static void session_conn_process_login(void *data)
@@ -1648,8 +1631,6 @@ static void session_conn_process_login(void *data)
 							ev_context->data;
 	struct iscsi_conn *conn = ev_context->conn;
 	struct iscsi_session *session = conn->session;
-	iscsi_login_context_t *c = &conn->login_context;
-	queue_task_t *qtask;
 
 	iscsi_ev_context_put(ev_context);
 	if (!(session->t->caps & CAP_LOGIN_OFFLOAD))
@@ -1676,8 +1657,7 @@ static void session_conn_process_login(void *data)
 		 * don't want to re-scan it on recovery.
 		 */
 		session_scan_host(session, session->hostno,
-				 c->qtask);
-		session->notify_qtask = NULL;
+				  conn->login_qtask);
 
 		log_warning("Connection%d:%d to [target: %s, portal: %s,%d] "
 			    "through [iface: %s] is operational now",
@@ -1686,10 +1666,11 @@ static void session_conn_process_login(void *data)
 			    session->nrec.conn[conn->id].port,
 			    session->nrec.iface.name);
 	} else {
-		session->notify_qtask = NULL;
-		mgmt_ipc_write_rsp(c->qtask, ISCSI_SUCCESS);
+		mgmt_ipc_write_rsp(conn->login_qtask, ISCSI_SUCCESS);
 	}
 
+	conn->login_qtask = NULL;
+
 	/*
 	 * reset ERL=0 reopen counter
 	 */
@@ -1699,9 +1680,9 @@ static void session_conn_process_login(void *data)
 	return;
 
 failed_login:
-	qtask = session->notify_qtask;
-	session->notify_qtask = NULL;
-	mgmt_ipc_write_rsp(qtask, ISCSI_ERR_LOGIN);
+	mgmt_ipc_write_rsp(conn->login_qtask, ISCSI_ERR_LOGIN);
+	conn->login_qtask = NULL;
+
 	if (ipc->destroy_conn(session->t->handle, session->id, conn->id))
 		log_error("can not safely destroy connection%d:%d",
 			session->id, conn->id);
@@ -1905,14 +1886,16 @@ static int __session_login_task(node_rec_t *rec, queue_task_t *qtask)
 			  "login early. You should manually login.");
 
 	conn->state = ISCSI_CONN_STATE_XPT_WAIT;
+	conn->login_qtask = qtask;
+
 	qtask->rsp.command = MGMT_IPC_SESSION_LOGIN;
 	qtask->rsp.err = ISCSI_SUCCESS;
 
-	if (iscsi_conn_connect(conn, qtask)) {
+	if (iscsi_conn_connect(conn)) {
 		log_debug(4, "Initial connect failed. Waiting %u seconds "
 			  "before trying to reconnect.",
 			  ISCSI_CONN_ERR_REOPEN_DELAY);
-		queue_delayed_reopen(qtask, ISCSI_CONN_ERR_REOPEN_DELAY);
+		queue_delayed_reopen(conn, ISCSI_CONN_ERR_REOPEN_DELAY);
 	}
 
 	return ISCSI_SUCCESS;
@@ -2035,11 +2018,10 @@ iscsi_sync_session(node_rec_t *rec, queue_task_t *qtask, uint32_t sid)
 		goto destroy_session;
 
 	qtask->rsp.command = MGMT_IPC_SESSION_SYNC;
+	session->conn[0].login_qtask = qtask;
 
 	log_debug(3, "Started sync iSCSI session %d", session->id);
-	session->notify_qtask = qtask;
-	session_conn_reopen(&session->conn[0], qtask,
-			    STOP_CONN_RECOVER);
+	session_conn_reopen(&session->conn[0], STOP_CONN_RECOVER);
 
 	return 0;
 
@@ -2074,32 +2056,11 @@ int session_logout_task(int sid, queue_task_t *qtask)
 	conn = &session->conn[0];
 
 	/*
-	 * If syncing up, in XPT_WAIT, and REOPENing, then return
-	 * an informative error, since the target for this session
-	 * is likely not connected
-	 */
-	if (session->notify_qtask &&
-	    (conn->state == ISCSI_CONN_STATE_XPT_WAIT) &&
-	    (session->r_stage == R_STAGE_SESSION_REOPEN)) {
-		log_warning("session %d cannot be terminted because "
-			    "it's trying to reconnect: try again later",
-			session->id);
-		return ISCSI_ERR_SESSION_NOT_CONNECTED;
-	}
-
-	/*
-	 * If syncing up and not reconnecting,
-	 * or if this is the initial login and mgmt_ipc
-	 * has not been notified of that result fail the logout request
+	 * TODO: We can check the iscsid and kernel state and kill an
+	 * in progress login.
 	 */
-	if (session->notify_qtask ||
-	    ((conn->state == ISCSI_CONN_STATE_XPT_WAIT ||
-	      conn->state == ISCSI_CONN_STATE_IN_LOGIN) &&
-	    (session->r_stage == R_STAGE_NO_CHANGE ||
-	     session->r_stage == R_STAGE_SESSION_REDIRECT))) {
-invalid_state:
-		log_error("session %d in invalid state for logout. "
-			   "Try again later", session->id);
+	if (conn->login_qtask) {
+		log_error("Logout failed. Login in progress.\n");
 		return ISCSI_ERR_INTERNAL;
 	}
 
@@ -2111,8 +2072,10 @@ invalid_state:
 
 	/* FIXME: logout all active connections */
 	conn = &session->conn[0];
-	if (conn->logout_qtask)
-		goto invalid_state;
+	if (conn->logout_qtask) {
+		log_error("Could not logout. Logout in progress.");
+		return ISCSI_ERR_INTERNAL;
+	}
 
 	qtask->conn = conn;
 	qtask->rsp.command = MGMT_IPC_SESSION_LOGOUT;
@@ -2133,7 +2096,7 @@ invalid_state:
 		conn_error(conn, "Could not send logout pdu. Dropping session");
 		/* fallthrough */
 	default:
-		rc = session_conn_shutdown(conn, qtask, ISCSI_SUCCESS);
+		rc = session_conn_shutdown(conn, ISCSI_SUCCESS);
 		break;
 	}
 
diff --git a/usr/initiator.h b/usr/initiator.h
index a4e01a2..65c31df 100644
--- a/usr/initiator.h
+++ b/usr/initiator.h
@@ -143,7 +143,6 @@ typedef struct iscsi_login_context {
 	int timeout;
 	int final;
 	enum iscsi_login_status ret;
-	struct queue_task *qtask;
 } iscsi_login_context_t;
 
 struct iscsi_session;
@@ -156,12 +155,14 @@ typedef struct iscsi_conn {
 	struct iscsi_session *session;
 	iscsi_login_context_t login_context;
 	struct iscsi_ev_context *recv_context;
-	struct queue_task *logout_qtask;
 	char data[ISCSI_DEF_MAX_RECV_SEG_LEN];
 	char host[NI_MAXHOST];	/* scratch */
 	enum iscsi_conn_state state;
 	int userspace_nop;
 
+	struct queue_task *login_qtask;
+	struct queue_task *logout_qtask;
+
 	struct timeval initial_connect_time;
 	actor_t login_timer;
 	actor_t nop_out_timer;
@@ -291,7 +292,6 @@ typedef struct iscsi_session {
 	/* connection reopens during recovery */
 	int reopen_cnt;
 	int reopen_max;
-	queue_task_t reopen_qtask;
 	iscsi_session_r_stage_e r_stage;
 	uint32_t replacement_timeout;
 
@@ -299,12 +299,6 @@ typedef struct iscsi_session {
 	int tgt_reset_timeout;
 	int lu_reset_timeout;
 	int abort_timeout;
-
-	/*
-	 * used for hw and sync up to notify caller that the operation
-	 * is complete
-	 */
-	queue_task_t *notify_qtask;
 } iscsi_session_t;
 
 #define	INVALID_SESSION_ID	(uint32_t)-1