numam-spdk/lib/iscsi/conn.c
Shuhei Matsumoto 8cf1945432 iscsi: Hot remove callback closes LUN directly without using event call
This patch is in the patch series to migrate iSCSI connection management
from core based to SPDK thread based.

The callback to hot removal of LUN, iscsi_conn_remove_lun, is called
on the same core when the corresponding LUN is opened. Additionally,
all operations in iscsi_conn_remove_lun are completed synchronously.

Hence inline _iscsi_conn_remove_lun into iscsi_conn_remove_lun.
Add assert to check the function is called on the specified core.

This change is helpful to achieve the goal of the patch series
because spdk_event can have two parameters but spdk_msg can have
only a single variable, and hence we cannot convert simply and have
to introduce a context allocated dynamically otherwise.

Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: Iaebf18265dfe839f7361b09539527a1806aed1c4
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/463551
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Broadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>
2019-08-08 05:35:01 +00:00

1514 lines
39 KiB
C

/*-
* BSD LICENSE
*
* Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>.
* Copyright (c) Intel Corporation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "spdk/stdinc.h"
#include "spdk/endian.h"
#include "spdk/env.h"
#include "spdk/event.h"
#include "spdk/likely.h"
#include "spdk/thread.h"
#include "spdk/queue.h"
#include "spdk/trace.h"
#include "spdk/net.h"
#include "spdk/sock.h"
#include "spdk/string.h"
#include "spdk_internal/log.h"
#include "iscsi/task.h"
#include "iscsi/conn.h"
#include "iscsi/tgt_node.h"
#include "iscsi/portal_grp.h"
#define MAKE_DIGEST_WORD(BUF, CRC32C) \
( ((*((uint8_t *)(BUF)+0)) = (uint8_t)((uint32_t)(CRC32C) >> 0)), \
((*((uint8_t *)(BUF)+1)) = (uint8_t)((uint32_t)(CRC32C) >> 8)), \
((*((uint8_t *)(BUF)+2)) = (uint8_t)((uint32_t)(CRC32C) >> 16)), \
((*((uint8_t *)(BUF)+3)) = (uint8_t)((uint32_t)(CRC32C) >> 24)))
#define SPDK_ISCSI_CONNECTION_MEMSET(conn) \
memset(&(conn)->portal, 0, sizeof(*(conn)) - \
offsetof(struct spdk_iscsi_conn, portal));
struct spdk_iscsi_conn *g_conns_array = MAP_FAILED;
static int g_conns_array_fd = -1;
static char g_shm_name[64];
static pthread_mutex_t g_conns_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct spdk_poller *g_shutdown_timer = NULL;
static void iscsi_conn_full_feature_migrate(void *arg1, void *arg2);
static void iscsi_conn_stop(struct spdk_iscsi_conn *conn);
static void iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group,
struct spdk_sock *sock);
static struct spdk_iscsi_conn *
allocate_conn(void)
{
struct spdk_iscsi_conn *conn;
int i;
pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
conn = &g_conns_array[i];
if (!conn->is_valid) {
SPDK_ISCSI_CONNECTION_MEMSET(conn);
conn->is_valid = 1;
pthread_mutex_unlock(&g_conns_mutex);
return conn;
}
}
pthread_mutex_unlock(&g_conns_mutex);
return NULL;
}
static void
free_conn(struct spdk_iscsi_conn *conn)
{
free(conn->portal_host);
free(conn->portal_port);
conn->is_valid = 0;
}
static struct spdk_iscsi_conn *
find_iscsi_connection_by_id(int cid)
{
if (g_conns_array != MAP_FAILED && g_conns_array[cid].is_valid == 1) {
return &g_conns_array[cid];
} else {
return NULL;
}
}
static void
_iscsi_conns_cleanup(void)
{
if (g_conns_array != MAP_FAILED) {
munmap(g_conns_array, sizeof(struct spdk_iscsi_conn) *
MAX_ISCSI_CONNECTIONS);
g_conns_array = MAP_FAILED;
}
if (g_conns_array_fd >= 0) {
close(g_conns_array_fd);
g_conns_array_fd = -1;
shm_unlink(g_shm_name);
}
}
int spdk_initialize_iscsi_conns(void)
{
size_t conns_size = sizeof(struct spdk_iscsi_conn) * MAX_ISCSI_CONNECTIONS;
uint32_t i;
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_init\n");
snprintf(g_shm_name, sizeof(g_shm_name), "/spdk_iscsi_conns.%d", spdk_app_get_shm_id());
g_conns_array_fd = shm_open(g_shm_name, O_RDWR | O_CREAT, 0600);
if (g_conns_array_fd < 0) {
SPDK_ERRLOG("could not shm_open %s\n", g_shm_name);
goto err;
}
if (ftruncate(g_conns_array_fd, conns_size) != 0) {
SPDK_ERRLOG("could not ftruncate\n");
goto err;
}
g_conns_array = mmap(0, conns_size, PROT_READ | PROT_WRITE, MAP_SHARED,
g_conns_array_fd, 0);
if (g_conns_array == MAP_FAILED) {
fprintf(stderr, "could not mmap cons array file %s (%d)\n", g_shm_name, errno);
goto err;
}
memset(g_conns_array, 0, conns_size);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
g_conns_array[i].id = i;
}
return 0;
err:
_iscsi_conns_cleanup();
return -1;
}
static void
iscsi_poll_group_add_conn(struct spdk_iscsi_poll_group *pg, struct spdk_iscsi_conn *conn)
{
int rc;
rc = spdk_sock_group_add_sock(pg->sock_group, conn->sock, iscsi_conn_sock_cb, conn);
if (rc < 0) {
SPDK_ERRLOG("Failed to add sock=%p of conn=%p\n", conn->sock, conn);
return;
}
conn->is_stopped = false;
STAILQ_INSERT_TAIL(&pg->connections, conn, link);
}
static void
iscsi_poll_group_remove_conn(struct spdk_iscsi_poll_group *pg, struct spdk_iscsi_conn *conn)
{
int rc;
rc = spdk_sock_group_remove_sock(pg->sock_group, conn->sock);
if (rc < 0) {
SPDK_ERRLOG("Failed to remove sock=%p of conn=%p\n", conn->sock, conn);
}
spdk_poller_unregister(&conn->flush_poller);
conn->is_stopped = true;
STAILQ_REMOVE(&pg->connections, conn, spdk_iscsi_conn, link);
}
int
spdk_iscsi_conn_construct(struct spdk_iscsi_portal *portal,
struct spdk_sock *sock)
{
struct spdk_iscsi_poll_group *pg;
struct spdk_iscsi_conn *conn;
int bufsize, i, rc;
conn = allocate_conn();
if (conn == NULL) {
SPDK_ERRLOG("Could not allocate connection.\n");
return -1;
}
pthread_mutex_lock(&g_spdk_iscsi.mutex);
conn->timeout = g_spdk_iscsi.timeout;
conn->nopininterval = g_spdk_iscsi.nopininterval;
conn->nopininterval *= spdk_get_ticks_hz(); /* seconds to TSC */
conn->nop_outstanding = false;
conn->data_out_cnt = 0;
conn->data_in_cnt = 0;
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
conn->MaxRecvDataSegmentLength = 8192; /* RFC3720(12.12) */
conn->portal = portal;
conn->pg_tag = portal->group->tag;
conn->portal_host = strdup(portal->host);
conn->portal_port = strdup(portal->port);
conn->sock = sock;
conn->state = ISCSI_CONN_STATE_INVALID;
conn->login_phase = ISCSI_SECURITY_NEGOTIATION_PHASE;
conn->ttt = 0;
conn->partial_text_parameter = NULL;
for (i = 0; i < MAX_CONNECTION_PARAMS; i++) {
conn->conn_param_state_negotiated[i] = false;
}
for (i = 0; i < MAX_SESSION_PARAMS; i++) {
conn->sess_param_state_negotiated[i] = false;
}
for (i = 0; i < DEFAULT_MAXR2T; i++) {
conn->outstanding_r2t_tasks[i] = NULL;
}
TAILQ_INIT(&conn->write_pdu_list);
TAILQ_INIT(&conn->snack_pdu_list);
TAILQ_INIT(&conn->queued_r2t_tasks);
TAILQ_INIT(&conn->active_r2t_tasks);
TAILQ_INIT(&conn->queued_datain_tasks);
memset(&conn->open_lun_descs, 0, sizeof(conn->open_lun_descs));
rc = spdk_sock_getaddr(sock, conn->target_addr, sizeof conn->target_addr, NULL,
conn->initiator_addr, sizeof conn->initiator_addr, NULL);
if (rc < 0) {
SPDK_ERRLOG("spdk_sock_getaddr() failed\n");
goto error_return;
}
bufsize = 2 * 1024 * 1024;
rc = spdk_sock_set_recvbuf(conn->sock, bufsize);
if (rc != 0) {
SPDK_ERRLOG("spdk_sock_set_recvbuf failed\n");
}
bufsize = 32 * 1024 * 1024 / g_spdk_iscsi.MaxConnections;
if (bufsize > 2 * 1024 * 1024) {
bufsize = 2 * 1024 * 1024;
}
rc = spdk_sock_set_sendbuf(conn->sock, bufsize);
if (rc != 0) {
SPDK_ERRLOG("spdk_sock_set_sendbuf failed\n");
}
/* set low water mark */
rc = spdk_sock_set_recvlowat(conn->sock, 1);
if (rc != 0) {
SPDK_ERRLOG("spdk_sock_set_recvlowat() failed\n");
goto error_return;
}
/* set default params */
rc = spdk_iscsi_conn_params_init(&conn->params);
if (rc < 0) {
SPDK_ERRLOG("iscsi_conn_params_init() failed\n");
goto error_return;
}
conn->logout_timer = NULL;
conn->shutdown_timer = NULL;
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Launching connection on acceptor thread\n");
conn->pending_task_cnt = 0;
conn->lcore = spdk_env_get_current_core();
pg = &g_spdk_iscsi.poll_group[conn->lcore];
iscsi_poll_group_add_conn(pg, conn);
return 0;
error_return:
spdk_iscsi_param_free(conn->params);
free_conn(conn);
return -1;
}
void
spdk_iscsi_conn_free_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
{
if (pdu->task) {
if (pdu->bhs.opcode == ISCSI_OP_SCSI_DATAIN) {
if (pdu->task->scsi.offset > 0) {
conn->data_in_cnt--;
if (pdu->bhs.flags & ISCSI_DATAIN_STATUS) {
/* Free the primary task after the last subtask done */
conn->data_in_cnt--;
spdk_iscsi_task_put(spdk_iscsi_task_get_primary(pdu->task));
}
spdk_iscsi_conn_handle_queued_datain_tasks(conn);
}
} else if (pdu->bhs.opcode == ISCSI_OP_SCSI_RSP &&
pdu->task->scsi.status != SPDK_SCSI_STATUS_GOOD) {
if (pdu->task->scsi.offset > 0) {
spdk_iscsi_task_put(spdk_iscsi_task_get_primary(pdu->task));
}
}
spdk_iscsi_task_put(pdu->task);
}
spdk_put_pdu(pdu);
}
static int
iscsi_conn_free_tasks(struct spdk_iscsi_conn *conn)
{
struct spdk_iscsi_pdu *pdu, *tmp_pdu;
struct spdk_iscsi_task *iscsi_task, *tmp_iscsi_task;
TAILQ_FOREACH_SAFE(pdu, &conn->write_pdu_list, tailq, tmp_pdu) {
TAILQ_REMOVE(&conn->write_pdu_list, pdu, tailq);
spdk_iscsi_conn_free_pdu(conn, pdu);
}
TAILQ_FOREACH_SAFE(pdu, &conn->snack_pdu_list, tailq, tmp_pdu) {
TAILQ_REMOVE(&conn->snack_pdu_list, pdu, tailq);
if (pdu->task) {
spdk_iscsi_task_put(pdu->task);
}
spdk_put_pdu(pdu);
}
TAILQ_FOREACH_SAFE(iscsi_task, &conn->queued_datain_tasks, link, tmp_iscsi_task) {
if (!iscsi_task->is_queued) {
TAILQ_REMOVE(&conn->queued_datain_tasks, iscsi_task, link);
spdk_iscsi_task_put(iscsi_task);
}
}
if (conn->pending_task_cnt) {
return -1;
}
return 0;
}
static void
_iscsi_conn_free(struct spdk_iscsi_conn *conn)
{
if (conn == NULL) {
return;
}
spdk_iscsi_param_free(conn->params);
/*
* Each connection pre-allocates its next PDU - make sure these get
* freed here.
*/
spdk_put_pdu(conn->pdu_in_progress);
free_conn(conn);
}
static void
iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn)
{
int rc;
struct spdk_iscsi_tgt_node *target;
if (conn->sess->connections > 1) {
/* connection specific cleanup */
} else if (!g_spdk_iscsi.AllowDuplicateIsid) {
/* clean up all tasks to all LUNs for session */
target = conn->sess->target;
if (target != NULL) {
rc = spdk_iscsi_tgt_node_cleanup_luns(conn, target);
if (rc < 0) {
SPDK_ERRLOG("target abort failed\n");
}
}
}
}
static void
iscsi_conn_free(struct spdk_iscsi_conn *conn)
{
struct spdk_iscsi_sess *sess;
int idx;
uint32_t i;
pthread_mutex_lock(&g_conns_mutex);
if (conn->sess == NULL) {
goto end;
}
idx = -1;
sess = conn->sess;
conn->sess = NULL;
for (i = 0; i < sess->connections; i++) {
if (sess->conns[i] == conn) {
idx = i;
break;
}
}
if (idx < 0) {
SPDK_ERRLOG("remove conn not found\n");
} else {
for (i = idx; i < sess->connections - 1; i++) {
sess->conns[i] = sess->conns[i + 1];
}
sess->conns[sess->connections - 1] = NULL;
sess->connections--;
if (sess->connections == 0) {
/* cleanup last connection */
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"cleanup last conn free sess\n");
spdk_free_sess(sess);
}
}
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Terminating connections(tsih %d): %d\n",
sess->tsih, sess->connections);
end:
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "cleanup free conn\n");
_iscsi_conn_free(conn);
pthread_mutex_unlock(&g_conns_mutex);
}
static int
_iscsi_conn_check_shutdown(void *arg)
{
struct spdk_iscsi_conn *conn = arg;
int rc;
rc = iscsi_conn_free_tasks(conn);
if (rc < 0) {
return 1;
}
spdk_poller_unregister(&conn->shutdown_timer);
iscsi_conn_stop(conn);
iscsi_conn_free(conn);
return 1;
}
static void
_iscsi_conn_destruct(struct spdk_iscsi_conn *conn)
{
struct spdk_iscsi_poll_group *pg;
int rc;
spdk_clear_all_transfer_task(conn, NULL, NULL);
assert(conn->lcore == spdk_env_get_current_core());
pg = &g_spdk_iscsi.poll_group[conn->lcore];
iscsi_poll_group_remove_conn(pg, conn);
spdk_sock_close(&conn->sock);
spdk_poller_unregister(&conn->logout_timer);
rc = iscsi_conn_free_tasks(conn);
if (rc < 0) {
/* The connection cannot be freed yet. Check back later. */
conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_shutdown, conn, 1000);
} else {
iscsi_conn_stop(conn);
iscsi_conn_free(conn);
}
}
static int
_iscsi_conn_check_pending_tasks(void *arg)
{
struct spdk_iscsi_conn *conn = arg;
if (conn->dev != NULL && spdk_scsi_dev_has_pending_tasks(conn->dev)) {
return 1;
}
spdk_poller_unregister(&conn->shutdown_timer);
_iscsi_conn_destruct(conn);
return 1;
}
void
spdk_iscsi_conn_destruct(struct spdk_iscsi_conn *conn)
{
/* If a connection is already in exited status, just return */
if (conn->state >= ISCSI_CONN_STATE_EXITED) {
return;
}
conn->state = ISCSI_CONN_STATE_EXITED;
if (conn->sess != NULL && conn->pending_task_cnt > 0) {
iscsi_conn_cleanup_backend(conn);
}
if (conn->dev != NULL && spdk_scsi_dev_has_pending_tasks(conn->dev)) {
conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_pending_tasks, conn, 1000);
} else {
_iscsi_conn_destruct(conn);
}
}
int
spdk_iscsi_get_active_conns(struct spdk_iscsi_tgt_node *target)
{
struct spdk_iscsi_conn *conn;
int num = 0;
int i;
pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
conn = find_iscsi_connection_by_id(i);
if (conn == NULL) {
continue;
}
if (target != NULL && conn->target != target) {
continue;
}
num++;
}
pthread_mutex_unlock(&g_conns_mutex);
return num;
}
static void
iscsi_conn_check_shutdown_cb(void *arg1)
{
_iscsi_conns_cleanup();
spdk_shutdown_iscsi_conns_done();
}
static int
iscsi_conn_check_shutdown(void *arg)
{
if (spdk_iscsi_get_active_conns(NULL) != 0) {
return 1;
}
spdk_poller_unregister(&g_shutdown_timer);
spdk_thread_send_msg(spdk_get_thread(), iscsi_conn_check_shutdown_cb, NULL);
return 1;
}
static void
iscsi_conn_close_lun(struct spdk_iscsi_conn *conn, int lun_id)
{
struct spdk_scsi_lun_desc *desc;
desc = conn->open_lun_descs[lun_id];
if (desc != NULL) {
spdk_scsi_lun_free_io_channel(desc);
spdk_scsi_lun_close(desc);
conn->open_lun_descs[lun_id] = NULL;
}
}
static void
iscsi_conn_close_luns(struct spdk_iscsi_conn *conn)
{
int i;
for (i = 0; i < SPDK_SCSI_DEV_MAX_LUN; i++) {
iscsi_conn_close_lun(conn, i);
}
}
static void
iscsi_conn_remove_lun(struct spdk_scsi_lun *lun, void *remove_ctx)
{
struct spdk_iscsi_conn *conn = remove_ctx;
int lun_id = spdk_scsi_lun_get_id(lun);
struct spdk_iscsi_pdu *pdu, *tmp_pdu;
struct spdk_iscsi_task *iscsi_task, *tmp_iscsi_task;
assert(conn->lcore == spdk_env_get_current_core());
/* If a connection is already in stating status, just return */
if (conn->state >= ISCSI_CONN_STATE_EXITING) {
return;
}
spdk_clear_all_transfer_task(conn, lun, NULL);
TAILQ_FOREACH_SAFE(pdu, &conn->write_pdu_list, tailq, tmp_pdu) {
/* If the pdu's LUN matches the LUN that was removed, free this
* PDU immediately. If the pdu's LUN is NULL, then we know
* the datain handling code already detected the hot removal,
* so we can free that PDU as well.
*/
if (pdu->task &&
(lun == pdu->task->scsi.lun || NULL == pdu->task->scsi.lun)) {
TAILQ_REMOVE(&conn->write_pdu_list, pdu, tailq);
spdk_iscsi_conn_free_pdu(conn, pdu);
}
}
TAILQ_FOREACH_SAFE(pdu, &conn->snack_pdu_list, tailq, tmp_pdu) {
if (pdu->task && (lun == pdu->task->scsi.lun)) {
TAILQ_REMOVE(&conn->snack_pdu_list, pdu, tailq);
spdk_iscsi_task_put(pdu->task);
spdk_put_pdu(pdu);
}
}
TAILQ_FOREACH_SAFE(iscsi_task, &conn->queued_datain_tasks, link, tmp_iscsi_task) {
if ((!iscsi_task->is_queued) && (lun == iscsi_task->scsi.lun)) {
TAILQ_REMOVE(&conn->queued_datain_tasks, iscsi_task, link);
spdk_iscsi_task_put(iscsi_task);
}
}
iscsi_conn_close_lun(conn, lun_id);
}
static void
iscsi_conn_open_luns(struct spdk_iscsi_conn *conn)
{
int i, rc;
struct spdk_scsi_lun *lun;
struct spdk_scsi_lun_desc *desc;
for (i = 0; i < SPDK_SCSI_DEV_MAX_LUN; i++) {
lun = spdk_scsi_dev_get_lun(conn->dev, i);
if (lun == NULL) {
continue;
}
rc = spdk_scsi_lun_open(lun, iscsi_conn_remove_lun, conn, &desc);
if (rc != 0) {
goto error;
}
rc = spdk_scsi_lun_allocate_io_channel(desc);
if (rc != 0) {
spdk_scsi_lun_close(desc);
goto error;
}
conn->open_lun_descs[i] = desc;
}
return;
error:
iscsi_conn_close_luns(conn);
}
/**
* This function will stop executing the specified connection.
*/
static void
iscsi_conn_stop(struct spdk_iscsi_conn *conn)
{
struct spdk_iscsi_tgt_node *target;
assert(conn->state == ISCSI_CONN_STATE_EXITED);
if (conn->sess != NULL &&
conn->sess->session_type == SESSION_TYPE_NORMAL &&
conn->full_feature) {
target = conn->sess->target;
pthread_mutex_lock(&target->mutex);
target->num_active_conns--;
pthread_mutex_unlock(&target->mutex);
iscsi_conn_close_luns(conn);
}
assert(conn->lcore == spdk_env_get_current_core());
}
void
spdk_iscsi_conns_start_exit(struct spdk_iscsi_tgt_node *target)
{
struct spdk_iscsi_conn *conn;
int i;
pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
conn = find_iscsi_connection_by_id(i);
if (conn == NULL) {
continue;
}
if (target != NULL && conn->target != target) {
continue;
}
/* Do not set conn->state if the connection has already started exiting.
* This ensures we do not move a connection from EXITED state back to EXITING.
*/
if (conn->state < ISCSI_CONN_STATE_EXITING) {
conn->state = ISCSI_CONN_STATE_EXITING;
}
}
pthread_mutex_unlock(&g_conns_mutex);
}
void
spdk_shutdown_iscsi_conns(void)
{
spdk_iscsi_conns_start_exit(NULL);
g_shutdown_timer = spdk_poller_register(iscsi_conn_check_shutdown, NULL, 1000);
}
int
spdk_iscsi_drop_conns(struct spdk_iscsi_conn *conn, const char *conn_match,
int drop_all)
{
struct spdk_iscsi_conn *xconn;
const char *xconn_match;
int i, num;
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_drop_conns\n");
num = 0;
pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
xconn = find_iscsi_connection_by_id(i);
if (xconn == NULL) {
continue;
}
if (xconn == conn) {
continue;
}
if (!drop_all && xconn->initiator_port == NULL) {
continue;
}
xconn_match =
drop_all ? xconn->initiator_name : spdk_scsi_port_get_name(xconn->initiator_port);
if (!strcasecmp(conn_match, xconn_match) &&
conn->target == xconn->target) {
if (num == 0) {
/*
* Only print this message before we report the
* first dropped connection.
*/
SPDK_ERRLOG("drop old connections %s by %s\n",
conn->target->name, conn_match);
}
SPDK_ERRLOG("exiting conn by %s (%s)\n",
xconn_match, xconn->initiator_addr);
if (xconn->sess != NULL) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "TSIH=%u\n", xconn->sess->tsih);
} else {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "TSIH=xx\n");
}
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "CID=%u\n", xconn->cid);
/* Do not set xconn->state if the connection has already started exiting.
* This ensures we do not move a connection from EXITED state back to EXITING.
*/
if (xconn->state < ISCSI_CONN_STATE_EXITING) {
xconn->state = ISCSI_CONN_STATE_EXITING;
}
num++;
}
}
pthread_mutex_unlock(&g_conns_mutex);
if (num != 0) {
SPDK_ERRLOG("exiting %d conns\n", num);
}
return 0;
}
/**
* \brief Reads data for the specified iSCSI connection from its TCP socket.
*
* The TCP socket is marked as non-blocking, so this function may not read
* all data requested.
*
* Returns SPDK_ISCSI_CONNECTION_FATAL if the recv() operation indicates a fatal
* error with the TCP connection (including if the TCP connection was closed
* unexpectedly.
*
* Otherwise returns the number of bytes successfully read.
*/
int
spdk_iscsi_conn_read_data(struct spdk_iscsi_conn *conn, int bytes,
void *buf)
{
int ret;
if (bytes == 0) {
return 0;
}
ret = spdk_sock_recv(conn->sock, buf, bytes);
if (ret > 0) {
spdk_trace_record(TRACE_ISCSI_READ_FROM_SOCKET_DONE, conn->id, ret, 0, 0);
return ret;
}
if (ret < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
return 0;
}
/* For connect reset issue, do not output error log */
if (errno == ECONNRESET) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_sock_recv() failed, errno %d: %s\n",
errno, spdk_strerror(errno));
} else {
SPDK_ERRLOG("spdk_sock_recv() failed, errno %d: %s\n",
errno, spdk_strerror(errno));
}
}
/* connection closed */
return SPDK_ISCSI_CONNECTION_FATAL;
}
int
spdk_iscsi_conn_readv_data(struct spdk_iscsi_conn *conn,
struct iovec *iov, int iovcnt)
{
int ret;
if (iov == NULL || iovcnt == 0) {
return 0;
}
if (iovcnt == 1) {
return spdk_iscsi_conn_read_data(conn, iov[0].iov_len,
iov[0].iov_base);
}
ret = spdk_sock_readv(conn->sock, iov, iovcnt);
if (ret > 0) {
spdk_trace_record(TRACE_ISCSI_READ_FROM_SOCKET_DONE, conn->id, ret, 0, 0);
return ret;
}
if (ret < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
return 0;
}
/* For connect reset issue, do not output error log */
if (errno == ECONNRESET) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_sock_readv() failed, errno %d: %s\n",
errno, spdk_strerror(errno));
} else {
SPDK_ERRLOG("spdk_sock_readv() failed, errno %d: %s\n",
errno, spdk_strerror(errno));
}
}
/* connection closed */
return SPDK_ISCSI_CONNECTION_FATAL;
}
void
spdk_iscsi_task_mgmt_cpl(struct spdk_scsi_task *scsi_task)
{
struct spdk_iscsi_task *task = spdk_iscsi_task_from_scsi_task(scsi_task);
spdk_iscsi_task_mgmt_response(task->conn, task);
spdk_iscsi_task_put(task);
}
static void
iscsi_task_copy_to_rsp_scsi_status(struct spdk_iscsi_task *primary,
struct spdk_scsi_task *task)
{
memcpy(primary->rsp_sense_data, task->sense_data, task->sense_data_len);
primary->rsp_sense_data_len = task->sense_data_len;
primary->rsp_scsi_status = task->status;
}
static void
iscsi_task_copy_from_rsp_scsi_status(struct spdk_scsi_task *task,
struct spdk_iscsi_task *primary)
{
memcpy(task->sense_data, primary->rsp_sense_data,
primary->rsp_sense_data_len);
task->sense_data_len = primary->rsp_sense_data_len;
task->status = primary->rsp_scsi_status;
}
static void
process_completed_read_subtask_list(struct spdk_iscsi_conn *conn,
struct spdk_iscsi_task *primary)
{
struct spdk_iscsi_task *subtask, *tmp;
TAILQ_FOREACH_SAFE(subtask, &primary->subtask_list, subtask_link, tmp) {
if (subtask->scsi.offset == primary->bytes_completed) {
TAILQ_REMOVE(&primary->subtask_list, subtask, subtask_link);
primary->bytes_completed += subtask->scsi.length;
spdk_iscsi_task_response(conn, subtask);
spdk_iscsi_task_put(subtask);
} else {
break;
}
}
}
static void
process_read_task_completion(struct spdk_iscsi_conn *conn,
struct spdk_iscsi_task *task,
struct spdk_iscsi_task *primary)
{
struct spdk_iscsi_task *tmp;
/* If the status of the completed subtask is the first failure,
* copy it to out-of-order subtasks and remember it as the status
* of the command,
*
* Even if the status of the completed task is success,
* there are any failed subtask ever, copy the first failed status
* to it.
*/
if (task->scsi.status != SPDK_SCSI_STATUS_GOOD) {
if (primary->rsp_scsi_status == SPDK_SCSI_STATUS_GOOD) {
TAILQ_FOREACH(tmp, &primary->subtask_list, subtask_link) {
spdk_scsi_task_copy_status(&tmp->scsi, &task->scsi);
}
iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);
}
} else if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) {
iscsi_task_copy_from_rsp_scsi_status(&task->scsi, primary);
}
if ((task != primary) &&
(task->scsi.offset != primary->bytes_completed)) {
TAILQ_FOREACH(tmp, &primary->subtask_list, subtask_link) {
if (task->scsi.offset < tmp->scsi.offset) {
TAILQ_INSERT_BEFORE(tmp, task, subtask_link);
return;
}
}
TAILQ_INSERT_TAIL(&primary->subtask_list, task, subtask_link);
return;
}
primary->bytes_completed += task->scsi.length;
spdk_iscsi_task_response(conn, task);
if ((task != primary) ||
(task->scsi.transfer_len == task->scsi.length)) {
spdk_iscsi_task_put(task);
}
process_completed_read_subtask_list(conn, primary);
}
void
spdk_iscsi_task_cpl(struct spdk_scsi_task *scsi_task)
{
struct spdk_iscsi_task *primary;
struct spdk_iscsi_task *task = spdk_iscsi_task_from_scsi_task(scsi_task);
struct spdk_iscsi_conn *conn = task->conn;
struct spdk_iscsi_pdu *pdu = task->pdu;
spdk_trace_record(TRACE_ISCSI_TASK_DONE, conn->id, 0, (uintptr_t)task, 0);
task->is_queued = false;
primary = spdk_iscsi_task_get_primary(task);
if (spdk_iscsi_task_is_read(primary)) {
process_read_task_completion(conn, task, primary);
} else {
primary->bytes_completed += task->scsi.length;
/* If the status of the subtask is the first failure, remember it as
* the status of the command and set it to the status of the primary
* task later.
*
* If the first failed task is the primary, two copies can be avoided
* but code simplicity is prioritized.
*/
if (task->scsi.status == SPDK_SCSI_STATUS_GOOD) {
if (task != primary) {
primary->scsi.data_transferred += task->scsi.data_transferred;
}
} else if (primary->rsp_scsi_status == SPDK_SCSI_STATUS_GOOD) {
iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);
}
if (primary->bytes_completed == primary->scsi.transfer_len) {
spdk_del_transfer_task(conn, primary->tag);
if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) {
iscsi_task_copy_from_rsp_scsi_status(&primary->scsi, primary);
}
spdk_iscsi_task_response(conn, primary);
/*
* Check if this is the last task completed for an iSCSI write
* that required child subtasks. If task != primary, we know
* for sure that it was part of an iSCSI write with child subtasks.
* The trickier case is when the last task completed was the initial
* task - in this case the task will have a smaller length than
* the overall transfer length.
*/
if (task != primary || task->scsi.length != task->scsi.transfer_len) {
TAILQ_REMOVE(&conn->active_r2t_tasks, primary, link);
spdk_iscsi_task_put(primary);
}
}
spdk_iscsi_task_put(task);
}
if (!task->parent) {
spdk_trace_record(TRACE_ISCSI_PDU_COMPLETED, 0, 0, (uintptr_t)pdu, 0);
}
}
static int
iscsi_get_pdu_length(struct spdk_iscsi_pdu *pdu, int header_digest,
int data_digest)
{
int data_len, enable_digest, total;
enable_digest = 1;
if (pdu->bhs.opcode == ISCSI_OP_LOGIN_RSP) {
enable_digest = 0;
}
total = ISCSI_BHS_LEN;
total += (4 * pdu->bhs.total_ahs_len);
if (enable_digest && header_digest) {
total += ISCSI_DIGEST_LEN;
}
data_len = DGET24(pdu->bhs.data_segment_len);
if (data_len > 0) {
total += ISCSI_ALIGN(data_len);
if (enable_digest && data_digest) {
total += ISCSI_DIGEST_LEN;
}
}
return total;
}
void
spdk_iscsi_conn_handle_nop(struct spdk_iscsi_conn *conn)
{
uint64_t tsc;
/**
* This function will be executed by nop_poller of iSCSI polling group, so
* we need to check the connection state first, then do the nop interval
* expiration check work.
*/
if ((conn->state == ISCSI_CONN_STATE_EXITED) ||
(conn->state == ISCSI_CONN_STATE_EXITING)) {
return;
}
/* Check for nop interval expiration */
tsc = spdk_get_ticks();
if (conn->nop_outstanding) {
if ((tsc - conn->last_nopin) > (conn->timeout * spdk_get_ticks_hz())) {
SPDK_ERRLOG("Timed out waiting for NOP-Out response from initiator\n");
SPDK_ERRLOG(" tsc=0x%lx, last_nopin=0x%lx\n", tsc, conn->last_nopin);
SPDK_ERRLOG(" initiator=%s, target=%s\n", conn->initiator_name,
conn->target_short_name);
conn->state = ISCSI_CONN_STATE_EXITING;
}
} else if (tsc - conn->last_nopin > conn->nopininterval) {
spdk_iscsi_send_nopin(conn);
}
}
/**
* \brief Makes one attempt to flush response PDUs back to the initiator.
*
* Builds a list of iovecs for response PDUs that must be sent back to the
* initiator and passes it to writev().
*
* Since the socket is non-blocking, writev() may not be able to flush all
* of the iovecs, and may even partially flush one of the iovecs. In this
* case, the partially flushed PDU will remain on the write_pdu_list with
* an offset pointing to the next byte to be flushed.
*
* Returns 0 if all PDUs were flushed.
*
* Returns 1 if some PDUs could not be flushed due to lack of send buffer
* space.
*
* Returns -1 if an exception error occurred indicating the TCP connection
* should be closed.
*/
static int
iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)
{
const int num_iovs = 32;
struct iovec iovs[num_iovs];
struct iovec *iov = iovs;
int iovcnt = 0;
int bytes = 0;
uint32_t total_length = 0;
uint32_t mapped_length = 0;
struct spdk_iscsi_pdu *pdu;
int pdu_length;
pdu = TAILQ_FIRST(&conn->write_pdu_list);
if (pdu == NULL) {
return 0;
}
/*
* Build up a list of iovecs for the first few PDUs in the
* connection's write_pdu_list. For the first PDU, check if it was
* partially written out the last time this function was called, and
* if so adjust the iovec array accordingly. This check is done in
* spdk_iscsi_build_iovs() and so applied to remaining PDUs too.
* But extra overhead is negligible.
*/
while (pdu != NULL && ((num_iovs - iovcnt) > 0)) {
iovcnt += spdk_iscsi_build_iovs(conn, &iovs[iovcnt], num_iovs - iovcnt,
pdu, &mapped_length);
total_length += mapped_length;
pdu = TAILQ_NEXT(pdu, tailq);
}
spdk_trace_record(TRACE_ISCSI_FLUSH_WRITEBUF_START, conn->id, total_length, 0, iovcnt);
bytes = spdk_sock_writev(conn->sock, iov, iovcnt);
if (bytes == -1) {
if (errno == EWOULDBLOCK || errno == EAGAIN) {
return 1;
} else {
SPDK_ERRLOG("spdk_sock_writev() failed, errno %d: %s\n",
errno, spdk_strerror(errno));
return -1;
}
}
spdk_trace_record(TRACE_ISCSI_FLUSH_WRITEBUF_DONE, conn->id, bytes, 0, 0);
pdu = TAILQ_FIRST(&conn->write_pdu_list);
/*
* Free any PDUs that were fully written. If a PDU was only
* partially written, update its writev_offset so that next
* time only the unwritten portion will be sent to writev().
*/
while (bytes > 0) {
pdu_length = iscsi_get_pdu_length(pdu, conn->header_digest,
conn->data_digest);
pdu_length -= pdu->writev_offset;
if (bytes >= pdu_length) {
bytes -= pdu_length;
TAILQ_REMOVE(&conn->write_pdu_list, pdu, tailq);
if ((conn->full_feature) &&
(conn->sess->ErrorRecoveryLevel >= 1) &&
spdk_iscsi_is_deferred_free_pdu(pdu)) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "stat_sn=%d\n",
from_be32(&pdu->bhs.stat_sn));
TAILQ_INSERT_TAIL(&conn->snack_pdu_list, pdu,
tailq);
} else {
spdk_iscsi_conn_free_pdu(conn, pdu);
}
pdu = TAILQ_FIRST(&conn->write_pdu_list);
} else {
pdu->writev_offset += bytes;
bytes = 0;
}
}
return TAILQ_EMPTY(&conn->write_pdu_list) ? 0 : 1;
}
/**
* \brief Flushes response PDUs back to the initiator.
*
* This function may return without all PDUs having flushed to the
* underlying TCP socket buffer - for example, in the case where the
* socket buffer is already full.
*
* During normal RUNNING connection state, if not all PDUs are flushed,
* then subsequent calls to this routine will eventually flush
* remaining PDUs.
*
* During other connection states (EXITING or LOGGED_OUT), this
* function will spin until all PDUs have successfully been flushed.
*/
static int
iscsi_conn_flush_pdus(void *_conn)
{
struct spdk_iscsi_conn *conn = _conn;
int rc;
if (conn->state == ISCSI_CONN_STATE_RUNNING) {
rc = iscsi_conn_flush_pdus_internal(conn);
if (rc == 0 && conn->flush_poller != NULL) {
spdk_poller_unregister(&conn->flush_poller);
} else if (rc == 1 && conn->flush_poller == NULL) {
conn->flush_poller = spdk_poller_register(iscsi_conn_flush_pdus,
conn, 50);
}
} else {
/*
* If the connection state is not RUNNING, then
* keep trying to flush PDUs until our list is
* empty - to make sure all data is sent before
* closing the connection.
*/
do {
rc = iscsi_conn_flush_pdus_internal(conn);
} while (rc == 1);
}
if (rc < 0 && conn->state < ISCSI_CONN_STATE_EXITING) {
/*
* If the poller has already started destruction of the connection,
* i.e. the socket read failed, then the connection state may already
* be EXITED. We don't want to set it back to EXITING in that case.
*/
conn->state = ISCSI_CONN_STATE_EXITING;
}
return 1;
}
static int
iscsi_dif_verify(struct spdk_iscsi_pdu *pdu, struct spdk_dif_ctx *dif_ctx)
{
struct iovec iov;
struct spdk_dif_error err_blk = {};
uint32_t num_blocks;
int rc;
iov.iov_base = pdu->data;
iov.iov_len = pdu->data_buf_len;
num_blocks = pdu->data_buf_len / dif_ctx->block_size;
rc = spdk_dif_verify(&iov, 1, num_blocks, dif_ctx, &err_blk);
if (rc != 0) {
SPDK_ERRLOG("DIF error detected. type=%d, offset=%" PRIu32 "\n",
err_blk.err_type, err_blk.err_offset);
}
return rc;
}
void
spdk_iscsi_conn_write_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
{
uint32_t crc32c;
int rc;
if (spdk_unlikely(spdk_iscsi_get_dif_ctx(conn, pdu, &pdu->dif_ctx))) {
rc = iscsi_dif_verify(pdu, &pdu->dif_ctx);
if (rc != 0) {
spdk_iscsi_conn_free_pdu(conn, pdu);
conn->state = ISCSI_CONN_STATE_EXITING;
return;
}
pdu->dif_insert_or_strip = true;
}
if (pdu->bhs.opcode != ISCSI_OP_LOGIN_RSP) {
/* Header Digest */
if (conn->header_digest) {
crc32c = spdk_iscsi_pdu_calc_header_digest(pdu);
MAKE_DIGEST_WORD(pdu->header_digest, crc32c);
}
/* Data Digest */
if (conn->data_digest && DGET24(pdu->bhs.data_segment_len) != 0) {
crc32c = spdk_iscsi_pdu_calc_data_digest(pdu);
MAKE_DIGEST_WORD(pdu->data_digest, crc32c);
}
}
TAILQ_INSERT_TAIL(&conn->write_pdu_list, pdu, tailq);
iscsi_conn_flush_pdus(conn);
}
#define GET_PDU_LOOP_COUNT 16
static int
iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn)
{
struct spdk_iscsi_pdu *pdu;
int i, rc;
/* Read new PDUs from network */
for (i = 0; i < GET_PDU_LOOP_COUNT; i++) {
rc = spdk_iscsi_read_pdu(conn, &pdu);
if (rc == 0) {
break;
} else if (rc < 0) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Failed to read pdu, error=%d\n", rc);
return SPDK_ISCSI_CONNECTION_FATAL;
}
if (conn->state == ISCSI_CONN_STATE_LOGGED_OUT) {
SPDK_ERRLOG("pdu received after logout\n");
spdk_put_pdu(pdu);
return SPDK_ISCSI_CONNECTION_FATAL;
}
rc = spdk_iscsi_execute(conn, pdu);
spdk_put_pdu(pdu);
if (rc < 0) {
SPDK_ERRLOG("spdk_iscsi_execute() fatal error on %s(%s)\n",
conn->target_port != NULL ? spdk_scsi_port_get_name(conn->target_port) : "NULL",
conn->initiator_port != NULL ? spdk_scsi_port_get_name(conn->initiator_port) : "NULL");
return SPDK_ISCSI_CONNECTION_FATAL;
}
spdk_trace_record(TRACE_ISCSI_TASK_EXECUTED, 0, 0, (uintptr_t)pdu, 0);
if (conn->is_stopped) {
break;
}
}
return i;
}
static void
iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_sock *sock)
{
struct spdk_iscsi_conn *conn = arg;
int rc;
assert(conn != NULL);
if ((conn->state == ISCSI_CONN_STATE_EXITED) ||
(conn->state == ISCSI_CONN_STATE_EXITING)) {
return;
}
/* Handle incoming PDUs */
rc = iscsi_conn_handle_incoming_pdus(conn);
if (rc < 0) {
conn->state = ISCSI_CONN_STATE_EXITING;
iscsi_conn_flush_pdus(conn);
}
}
static void
iscsi_conn_full_feature_migrate(void *arg1, void *arg2)
{
struct spdk_iscsi_conn *conn = arg1;
struct spdk_iscsi_poll_group *pg;
if (conn->sess->session_type == SESSION_TYPE_NORMAL) {
iscsi_conn_open_luns(conn);
}
/* The poller has been unregistered, so now we can re-register it on the new core. */
conn->lcore = spdk_env_get_current_core();
pg = &g_spdk_iscsi.poll_group[conn->lcore];
iscsi_poll_group_add_conn(pg, conn);
}
static uint32_t g_next_core = SPDK_ENV_LCORE_ID_ANY;
void
spdk_iscsi_conn_schedule(struct spdk_iscsi_conn *conn)
{
struct spdk_iscsi_poll_group *pg;
struct spdk_event *event;
struct spdk_iscsi_tgt_node *target;
uint32_t i;
uint32_t lcore;
lcore = SPDK_ENV_LCORE_ID_ANY;
if (conn->sess->session_type != SESSION_TYPE_NORMAL) {
/* Leave all non-normal sessions on the acceptor
* thread. */
return;
}
for (i = 0; i < spdk_env_get_core_count(); i++) {
if (g_next_core > spdk_env_get_last_core()) {
g_next_core = spdk_env_get_first_core();
}
lcore = g_next_core;
g_next_core = spdk_env_get_next_core(g_next_core);
break;
}
if (i >= spdk_env_get_core_count()) {
SPDK_ERRLOG("Unable to schedule connection on allowed CPU core. Scheduling on first core instead.\n");
lcore = spdk_env_get_first_core();
}
target = conn->sess->target;
pthread_mutex_lock(&target->mutex);
target->num_active_conns++;
if (target->num_active_conns == 1) {
/**
* This is the only active connection for this target node.
* Save the lcore in the target node so it can be used for
* any other connections to this target node.
*/
target->lcore = lcore;
} else {
/**
* There are other active connections for this target node.
* Ignore the lcore specified by the allocator and use the
* the target node's lcore to ensure this connection runs on
* the same lcore as other connections for this target node.
*/
lcore = target->lcore;
}
pthread_mutex_unlock(&target->mutex);
assert(conn->lcore == spdk_env_get_current_core());
pg = &g_spdk_iscsi.poll_group[conn->lcore];
iscsi_poll_group_remove_conn(pg, conn);
conn->last_nopin = spdk_get_ticks();
event = spdk_event_allocate(lcore, iscsi_conn_full_feature_migrate,
conn, NULL);
spdk_event_call(event);
}
static int
logout_timeout(void *arg)
{
struct spdk_iscsi_conn *conn = arg;
spdk_iscsi_conn_destruct(conn);
return -1;
}
void
spdk_iscsi_conn_logout(struct spdk_iscsi_conn *conn)
{
conn->state = ISCSI_CONN_STATE_LOGGED_OUT;
conn->logout_timer = spdk_poller_register(logout_timeout, conn, ISCSI_LOGOUT_TIMEOUT * 1000000);
}
SPDK_TRACE_REGISTER_FN(iscsi_conn_trace, "iscsi_conn", TRACE_GROUP_ISCSI)
{
spdk_trace_register_owner(OWNER_ISCSI_CONN, 'c');
spdk_trace_register_object(OBJECT_ISCSI_PDU, 'p');
spdk_trace_register_description("ISCSI_READ_DONE", TRACE_ISCSI_READ_FROM_SOCKET_DONE,
OWNER_ISCSI_CONN, OBJECT_NONE, 0, 0, "");
spdk_trace_register_description("ISCSI_WRITE_START", TRACE_ISCSI_FLUSH_WRITEBUF_START,
OWNER_ISCSI_CONN, OBJECT_NONE, 0, 0, "iovec: ");
spdk_trace_register_description("ISCSI_WRITE_DONE", TRACE_ISCSI_FLUSH_WRITEBUF_DONE,
OWNER_ISCSI_CONN, OBJECT_NONE, 0, 0, "");
spdk_trace_register_description("ISCSI_READ_PDU", TRACE_ISCSI_READ_PDU,
OWNER_ISCSI_CONN, OBJECT_ISCSI_PDU, 1, 0, "opc: ");
spdk_trace_register_description("ISCSI_TASK_DONE", TRACE_ISCSI_TASK_DONE,
OWNER_ISCSI_CONN, OBJECT_SCSI_TASK, 0, 0, "");
spdk_trace_register_description("ISCSI_TASK_QUEUE", TRACE_ISCSI_TASK_QUEUE,
OWNER_ISCSI_CONN, OBJECT_SCSI_TASK, 1, 1, "pdu: ");
spdk_trace_register_description("ISCSI_TASK_EXECUTED", TRACE_ISCSI_TASK_EXECUTED,
OWNER_ISCSI_CONN, OBJECT_ISCSI_PDU, 0, 0, "");
spdk_trace_register_description("ISCSI_PDU_COMPLETED", TRACE_ISCSI_PDU_COMPLETED,
OWNER_ISCSI_CONN, OBJECT_ISCSI_PDU, 0, 0, "");
}