Commit 893e02a5 authored by Shuhei Matsumoto's avatar Shuhei Matsumoto Committed by Changpeng Liu
Browse files

iscsi: Remove the prefix spdk_ from names of private functions 



iSCSI library had used the prefix spdk_ for most functions regardless
of private or public. Using the prefix spdk_ only for public functions
will be helpful to distinguish private and public functions, and
will be helpful to investigate issues or do further improvement.

Besides in iscsi.c static variable spdk_arc4random_initialized had
the prefix spdk_, and change it to g_arc4random_initialized according
to the SPDK's good practice.

iSCSI library still have some issues but is more stable than before
and now will be the good time to adjust the naming rule to other
libraries.

This patch doesn't change any behavior.

Change-Id: Ia0b8585a7ce6662cabc0e6f57b7ccb8a40342297
Signed-off-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/449396


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
parent b7039655

lib/iscsi/acceptor.c

+2 −2
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ 
#define ACCEPT_TIMEOUT_US 1000 /* 1ms */



static int

spdk_iscsi_portal_accept(void *arg)

iscsi_portal_accept(void *arg)

{

	struct spdk_iscsi_portal	*portal = arg;

	struct spdk_sock		*sock;
@@ -81,7 +81,7 @@ spdk_iscsi_portal_accept(void *arg) 
void

spdk_iscsi_acceptor_start(struct spdk_iscsi_portal *p)

{

	p->acceptor_poller = spdk_poller_register(spdk_iscsi_portal_accept, p, ACCEPT_TIMEOUT_US);

	p->acceptor_poller = spdk_poller_register(iscsi_portal_accept, p, ACCEPT_TIMEOUT_US);

}



void

lib/iscsi/conn.c

+78 −79
Original line number Diff line number Diff line
@@ -73,11 +73,11 @@ static pthread_mutex_t g_conns_mutex = PTHREAD_MUTEX_INITIALIZER; 


static struct spdk_poller *g_shutdown_timer = NULL;



static uint32_t spdk_iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask);

static uint32_t iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask);



static void spdk_iscsi_conn_full_feature_migrate(void *arg1, void *arg2);

static void spdk_iscsi_conn_stop(struct spdk_iscsi_conn *conn);

static void spdk_iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group,

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 *
@@ -110,7 +110,7 @@ free_conn(struct spdk_iscsi_conn *conn) 
}



static struct spdk_iscsi_conn *

spdk_find_iscsi_connection_by_id(int cid)

find_iscsi_connection_by_id(int cid)

{

	if (g_conns_array[cid].is_valid == 1) {

		return &g_conns_array[cid];
@@ -177,7 +177,7 @@ err: 
}



static void

spdk_iscsi_poll_group_add_conn_sock(struct spdk_iscsi_conn *conn)

iscsi_poll_group_add_conn_sock(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_poll_group *poll_group;

	int rc;
@@ -186,14 +186,14 @@ spdk_iscsi_poll_group_add_conn_sock(struct spdk_iscsi_conn *conn) 


	poll_group = &g_spdk_iscsi.poll_group[conn->lcore];



	rc = spdk_sock_group_add_sock(poll_group->sock_group, conn->sock, spdk_iscsi_conn_sock_cb, conn);

	rc = spdk_sock_group_add_sock(poll_group->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);

	}

}



static void

spdk_iscsi_poll_group_remove_conn_sock(struct spdk_iscsi_conn *conn)

iscsi_poll_group_remove_conn_sock(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_poll_group *poll_group;

	int rc;
@@ -209,7 +209,7 @@ spdk_iscsi_poll_group_remove_conn_sock(struct spdk_iscsi_conn *conn) 
}



static void

spdk_iscsi_poll_group_add_conn(struct spdk_iscsi_conn *conn)

iscsi_poll_group_add_conn(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_poll_group *poll_group;
@@ -219,11 +219,11 @@ spdk_iscsi_poll_group_add_conn(struct spdk_iscsi_conn *conn) 


	conn->is_stopped = false;

	STAILQ_INSERT_TAIL(&poll_group->connections, conn, link);

	spdk_iscsi_poll_group_add_conn_sock(conn);

	iscsi_poll_group_add_conn_sock(conn);

}



static void

spdk_iscsi_poll_group_remove_conn(struct spdk_iscsi_conn *conn)

iscsi_poll_group_remove_conn(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_poll_group *poll_group;
@@ -347,7 +347,7 @@ spdk_iscsi_conn_construct(struct spdk_iscsi_portal *portal, 
	conn->lcore = spdk_env_get_current_core();

	__sync_fetch_and_add(&g_num_connections[conn->lcore], 1);



	spdk_iscsi_poll_group_add_conn(conn);

	iscsi_poll_group_add_conn(conn);

	return 0;



error_return:
@@ -380,7 +380,8 @@ spdk_iscsi_conn_free_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pd 
	spdk_put_pdu(pdu);

}



static int spdk_iscsi_conn_free_tasks(struct spdk_iscsi_conn *conn)

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;
@@ -413,7 +414,7 @@ static int spdk_iscsi_conn_free_tasks(struct spdk_iscsi_conn *conn) 
}



static void

_spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn)

_iscsi_conn_free(struct spdk_iscsi_conn *conn)

{

	if (conn == NULL) {

		return;
@@ -431,7 +432,7 @@ _spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn) 
}



static void

spdk_iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn)

iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn)

{

	int rc;

	struct spdk_iscsi_tgt_node *target;
@@ -451,7 +452,7 @@ spdk_iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn) 
}



static void

spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn)

iscsi_conn_free(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_sess *sess;

	int idx;
@@ -496,53 +497,53 @@ spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn) 


end:

	SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "cleanup free conn\n");

	_spdk_iscsi_conn_free(conn);

	_iscsi_conn_free(conn);



	pthread_mutex_unlock(&g_conns_mutex);

}



static int

_spdk_iscsi_conn_check_shutdown(void *arg)

_iscsi_conn_check_shutdown(void *arg)

{

	struct spdk_iscsi_conn *conn = arg;

	int rc;



	rc = spdk_iscsi_conn_free_tasks(conn);

	rc = iscsi_conn_free_tasks(conn);

	if (rc < 0) {

		return 1;

	}



	spdk_poller_unregister(&conn->shutdown_timer);



	spdk_iscsi_conn_stop(conn);

	spdk_iscsi_conn_free(conn);

	iscsi_conn_stop(conn);

	iscsi_conn_free(conn);



	return 1;

}



static void

_spdk_iscsi_conn_destruct(struct spdk_iscsi_conn *conn)

_iscsi_conn_destruct(struct spdk_iscsi_conn *conn)

{

	int rc;



	spdk_clear_all_transfer_task(conn, NULL, NULL);

	spdk_iscsi_poll_group_remove_conn_sock(conn);

	iscsi_poll_group_remove_conn_sock(conn);

	spdk_sock_close(&conn->sock);

	spdk_poller_unregister(&conn->logout_timer);

	spdk_poller_unregister(&conn->flush_poller);



	rc = spdk_iscsi_conn_free_tasks(conn);

	rc = iscsi_conn_free_tasks(conn);

	if (rc < 0) {

		/* The connection cannot be freed yet. Check back later. */

		conn->shutdown_timer = spdk_poller_register(_spdk_iscsi_conn_check_shutdown, conn, 1000);

		conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_shutdown, conn, 1000);

	} else {

		spdk_iscsi_conn_stop(conn);

		spdk_iscsi_conn_free(conn);

		iscsi_conn_stop(conn);

		iscsi_conn_free(conn);

	}

}



static int

_spdk_iscsi_conn_check_pending_tasks(void *arg)

_iscsi_conn_check_pending_tasks(void *arg)

{

	struct spdk_iscsi_conn *conn = arg;
@@ -552,7 +553,7 @@ _spdk_iscsi_conn_check_pending_tasks(void *arg) 


	spdk_poller_unregister(&conn->shutdown_timer);



	_spdk_iscsi_conn_destruct(conn);

	_iscsi_conn_destruct(conn);



	return 1;

}
@@ -568,18 +569,18 @@ spdk_iscsi_conn_destruct(struct spdk_iscsi_conn *conn) 
	conn->state = ISCSI_CONN_STATE_EXITED;



	if (conn->sess != NULL && conn->pending_task_cnt > 0) {

		spdk_iscsi_conn_cleanup_backend(conn);

		iscsi_conn_cleanup_backend(conn);

	}



	if (conn->dev != NULL && spdk_scsi_dev_has_pending_tasks(conn->dev)) {

		conn->shutdown_timer = spdk_poller_register(_spdk_iscsi_conn_check_pending_tasks, conn, 1000);

		conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_pending_tasks, conn, 1000);

	} else {

		_spdk_iscsi_conn_destruct(conn);

		_iscsi_conn_destruct(conn);

	}

}



static int

spdk_iscsi_get_active_conns(void)

iscsi_get_active_conns(void)

{

	struct spdk_iscsi_conn *conn;

	int num = 0;
@@ -587,7 +588,7 @@ spdk_iscsi_get_active_conns(void) 


	pthread_mutex_lock(&g_conns_mutex);

	for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {

		conn = spdk_find_iscsi_connection_by_id(i);

		conn = find_iscsi_connection_by_id(i);

		if (conn == NULL) {

			continue;

		}
@@ -598,7 +599,7 @@ spdk_iscsi_get_active_conns(void) 
}



static void

spdk_iscsi_conns_cleanup(void)

iscsi_conns_cleanup(void)

{

	free(g_num_connections);

	munmap(g_conns_array, sizeof(struct spdk_iscsi_conn) *
@@ -611,24 +612,24 @@ spdk_iscsi_conns_cleanup(void) 
}



static void

spdk_iscsi_conn_check_shutdown_cb(void *arg1, void *arg2)

iscsi_conn_check_shutdown_cb(void *arg1, void *arg2)

{

	spdk_iscsi_conns_cleanup();

	iscsi_conns_cleanup();

	spdk_shutdown_iscsi_conns_done();

}



static int

spdk_iscsi_conn_check_shutdown(void *arg)

iscsi_conn_check_shutdown(void *arg)

{

	struct spdk_event *event;



	if (spdk_iscsi_get_active_conns() != 0) {

	if (iscsi_get_active_conns() != 0) {

		return 1;

	}



	spdk_poller_unregister(&g_shutdown_timer);

	event = spdk_event_allocate(spdk_env_get_current_core(),

				    spdk_iscsi_conn_check_shutdown_cb, NULL, NULL);

				    iscsi_conn_check_shutdown_cb, NULL, NULL);

	spdk_event_call(event);



	return 1;
@@ -745,7 +746,7 @@ error: 
 *  This function will stop executing the specified connection.

 */

static void

spdk_iscsi_conn_stop(struct spdk_iscsi_conn *conn)

iscsi_conn_stop(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_tgt_node *target;
@@ -763,7 +764,7 @@ spdk_iscsi_conn_stop(struct spdk_iscsi_conn *conn) 
	assert(conn->lcore == spdk_env_get_current_core());



	__sync_fetch_and_sub(&g_num_connections[conn->lcore], 1);

	spdk_iscsi_poll_group_remove_conn(conn);

	iscsi_poll_group_remove_conn(conn);

}



void spdk_shutdown_iscsi_conns(void)
@@ -774,7 +775,7 @@ void spdk_shutdown_iscsi_conns(void) 
	pthread_mutex_lock(&g_conns_mutex);



	for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {

		conn = spdk_find_iscsi_connection_by_id(i);

		conn = find_iscsi_connection_by_id(i);

		if (conn == NULL) {

			continue;

		}
@@ -788,8 +789,7 @@ void spdk_shutdown_iscsi_conns(void) 
	}



	pthread_mutex_unlock(&g_conns_mutex);

	g_shutdown_timer = spdk_poller_register(spdk_iscsi_conn_check_shutdown, NULL,

						1000);

	g_shutdown_timer = spdk_poller_register(iscsi_conn_check_shutdown, NULL, 1000);

}



int
@@ -805,7 +805,7 @@ spdk_iscsi_drop_conns(struct spdk_iscsi_conn *conn, const char *conn_match, 
	num = 0;

	pthread_mutex_lock(&g_conns_mutex);

	for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {

		xconn = spdk_find_iscsi_connection_by_id(i);

		xconn = find_iscsi_connection_by_id(i);



		if (xconn == NULL) {

			continue;
@@ -962,7 +962,7 @@ spdk_iscsi_task_mgmt_cpl(struct spdk_scsi_task *scsi_task) 
}



static void

spdk_iscsi_task_copy_to_rsp_scsi_status(struct spdk_iscsi_task *primary,

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);
@@ -971,7 +971,7 @@ spdk_iscsi_task_copy_to_rsp_scsi_status(struct spdk_iscsi_task *primary, 
}



static void

spdk_iscsi_task_copy_from_rsp_scsi_status(struct spdk_scsi_task *task,

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,
@@ -1018,10 +1018,10 @@ process_read_task_completion(struct spdk_iscsi_conn *conn, 
			TAILQ_FOREACH(tmp, &primary->subtask_list, subtask_link) {

				spdk_scsi_task_copy_status(&tmp->scsi, &task->scsi);

			}

			spdk_iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);

			iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);

		}

	} else if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) {

		spdk_iscsi_task_copy_from_rsp_scsi_status(&task->scsi, primary);

		iscsi_task_copy_from_rsp_scsi_status(&task->scsi, primary);

	}



	if ((task != primary) &&
@@ -1079,13 +1079,13 @@ spdk_iscsi_task_cpl(struct spdk_scsi_task *scsi_task) 
				primary->scsi.data_transferred += task->scsi.data_transferred;

			}

		} else if (primary->rsp_scsi_status == SPDK_SCSI_STATUS_GOOD) {

			spdk_iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);

			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) {

				spdk_iscsi_task_copy_from_rsp_scsi_status(&primary->scsi, primary);

				iscsi_task_copy_from_rsp_scsi_status(&primary->scsi, primary);

			}

			spdk_iscsi_task_response(conn, primary);

			/*
@@ -1109,7 +1109,7 @@ spdk_iscsi_task_cpl(struct spdk_scsi_task *scsi_task) 
}



static int

spdk_iscsi_get_pdu_length(struct spdk_iscsi_pdu *pdu, int header_digest,

iscsi_get_pdu_length(struct spdk_iscsi_pdu *pdu, int header_digest,

		     int data_digest)

{

	int data_len, enable_digest, total;
@@ -1188,7 +1188,7 @@ spdk_iscsi_conn_handle_nop(struct spdk_iscsi_conn *conn) 
 * should be closed.

 */

static int

spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)

iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)

{

	const int num_iovs = 32;

	struct iovec iovs[num_iovs];
@@ -1244,8 +1244,7 @@ spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn) 
	 *  time only the unwritten portion will be sent to writev().

	 */

	while (bytes > 0) {

		pdu_length = spdk_iscsi_get_pdu_length(pdu,

						       conn->header_digest,

		pdu_length = iscsi_get_pdu_length(pdu, conn->header_digest,

						  conn->data_digest);

		pdu_length -= pdu->writev_offset;
@@ -1289,17 +1288,17 @@ spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn) 
 * function will spin until all PDUs have successfully been flushed.

 */

static int

spdk_iscsi_conn_flush_pdus(void *_conn)

iscsi_conn_flush_pdus(void *_conn)

{

	struct spdk_iscsi_conn *conn = _conn;

	int rc;



	if (conn->state == ISCSI_CONN_STATE_RUNNING) {

		rc = spdk_iscsi_conn_flush_pdus_internal(conn);

		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(spdk_iscsi_conn_flush_pdus,

			conn->flush_poller = spdk_poller_register(iscsi_conn_flush_pdus,

					     conn, 50);

		}

	} else {
@@ -1310,7 +1309,7 @@ spdk_iscsi_conn_flush_pdus(void *_conn) 
		 * closing the connection.

		 */

		do {

			rc = spdk_iscsi_conn_flush_pdus_internal(conn);

			rc = iscsi_conn_flush_pdus_internal(conn);

		} while (rc == 1);

	}
@@ -1327,7 +1326,7 @@ spdk_iscsi_conn_flush_pdus(void *_conn) 
}



static int

spdk_iscsi_dif_verify(struct spdk_iscsi_pdu *pdu, struct spdk_dif_ctx *dif_ctx)

iscsi_dif_verify(struct spdk_iscsi_pdu *pdu, struct spdk_dif_ctx *dif_ctx)

{

	struct iovec iov;

	struct spdk_dif_error err_blk = {};
@@ -1354,7 +1353,7 @@ spdk_iscsi_conn_write_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p 
	int rc;



	if (spdk_unlikely(spdk_iscsi_get_dif_ctx(conn, pdu, &pdu->dif_ctx))) {

		rc = spdk_iscsi_dif_verify(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;
@@ -1378,13 +1377,13 @@ spdk_iscsi_conn_write_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p 
	}



	TAILQ_INSERT_TAIL(&conn->write_pdu_list, pdu, tailq);

	spdk_iscsi_conn_flush_pdus(conn);

	iscsi_conn_flush_pdus(conn);

}



#define GET_PDU_LOOP_COUNT	16



static int

spdk_iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn)

iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn)

{

	struct spdk_iscsi_pdu *pdu;

	int i, rc;
@@ -1423,7 +1422,7 @@ spdk_iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn) 
}



static void

spdk_iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_sock *sock)

iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_sock *sock)

{

	struct spdk_iscsi_conn *conn = arg;

	int rc;
@@ -1436,15 +1435,15 @@ spdk_iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_so 
	}



	/* Handle incoming PDUs */

	rc = spdk_iscsi_conn_handle_incoming_pdus(conn);

	rc = iscsi_conn_handle_incoming_pdus(conn);

	if (rc < 0) {

		conn->state = ISCSI_CONN_STATE_EXITING;

		spdk_iscsi_conn_flush_pdus(conn);

		iscsi_conn_flush_pdus(conn);

	}

}



static void

spdk_iscsi_conn_full_feature_migrate(void *arg1, void *arg2)

iscsi_conn_full_feature_migrate(void *arg1, void *arg2)

{

	struct spdk_iscsi_conn *conn = arg1;
@@ -1454,7 +1453,7 @@ spdk_iscsi_conn_full_feature_migrate(void *arg1, void *arg2) 


	/* The poller has been unregistered, so now we can re-register it on the new core. */

	conn->lcore = spdk_env_get_current_core();

	spdk_iscsi_poll_group_add_conn(conn);

	iscsi_poll_group_add_conn(conn);

}



void
@@ -1464,7 +1463,7 @@ spdk_iscsi_conn_migration(struct spdk_iscsi_conn *conn) 
	struct spdk_event		*event;

	struct spdk_iscsi_tgt_node *target;



	lcore = spdk_iscsi_conn_allocate_reactor(conn->portal->cpumask);

	lcore = iscsi_conn_allocate_reactor(conn->portal->cpumask);

	if (conn->sess->session_type == SESSION_TYPE_NORMAL) {

		target = conn->sess->target;

		pthread_mutex_lock(&target->mutex);
@@ -1488,13 +1487,13 @@ spdk_iscsi_conn_migration(struct spdk_iscsi_conn *conn) 
		pthread_mutex_unlock(&target->mutex);

	}



	spdk_iscsi_poll_group_remove_conn_sock(conn);

	iscsi_poll_group_remove_conn_sock(conn);

	spdk_poller_unregister(&conn->flush_poller);

	spdk_iscsi_conn_stop(conn);

	iscsi_conn_stop(conn);



	__sync_fetch_and_add(&g_num_connections[lcore], 1);

	conn->last_nopin = spdk_get_ticks();

	event = spdk_event_allocate(lcore, spdk_iscsi_conn_full_feature_migrate,

	event = spdk_event_allocate(lcore, iscsi_conn_full_feature_migrate,

				    conn, NULL);

	spdk_event_call(event);

}
@@ -1512,7 +1511,7 @@ spdk_iscsi_conn_get_min_per_core(void) 
}



static uint32_t

spdk_iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask)

iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask)

{

	uint32_t i, selected_core;

	int32_t num_pollers, min_pollers;

lib/iscsi/init_grp.c

+56 −55
Original line number Diff line number Diff line
@@ -43,7 +43,7 @@ 
#include "iscsi/init_grp.h"



static struct spdk_iscsi_init_grp *

spdk_iscsi_init_grp_create(int tag)

iscsi_init_grp_create(int tag)

{

	struct spdk_iscsi_init_grp *ig;
@@ -60,7 +60,7 @@ spdk_iscsi_init_grp_create(int tag) 
}



static struct spdk_iscsi_initiator_name *

spdk_iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name)

iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name)

{

	struct spdk_iscsi_initiator_name *iname;
@@ -73,7 +73,7 @@ spdk_iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name) 
}



static int

spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)

iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)

{

	struct spdk_iscsi_initiator_name *iname;

	char *p;
@@ -88,7 +88,7 @@ spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name) 
		return -EINVAL;

	}



	iname = spdk_iscsi_init_grp_find_initiator(ig, name);

	iname = iscsi_init_grp_find_initiator(ig, name);

	if (iname != NULL) {

		return -EEXIST;

	}
@@ -122,11 +122,11 @@ spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name) 
}



static int

spdk_iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name)

iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name)

{

	struct spdk_iscsi_initiator_name *iname;



	iname = spdk_iscsi_init_grp_find_initiator(ig, name);

	iname = iscsi_init_grp_find_initiator(ig, name);

	if (iname == NULL) {

		return -ENOENT;

	}
@@ -139,13 +139,14 @@ spdk_iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name) 
}



static int

spdk_iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames)

iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_inames,

			      char **inames)

{

	int i;

	int rc;



	for (i = 0; i < num_inames; i++) {

		rc = spdk_iscsi_init_grp_add_initiator(ig, inames[i]);

		rc = iscsi_init_grp_add_initiator(ig, inames[i]);

		if (rc < 0) {

			goto cleanup;

		}
@@ -154,13 +155,13 @@ spdk_iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_iname 


cleanup:

	for (; i > 0; --i) {

		spdk_iscsi_init_grp_delete_initiator(ig, inames[i - 1]);

		iscsi_init_grp_delete_initiator(ig, inames[i - 1]);

	}

	return rc;

}



static void

spdk_iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig)

iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig)

{

	struct spdk_iscsi_initiator_name *iname, *tmp;
@@ -173,13 +174,13 @@ spdk_iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig) 
}



static int

spdk_iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames)

iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames)

{

	int i;

	int rc;



	for (i = 0; i < num_inames; i++) {

		rc = spdk_iscsi_init_grp_delete_initiator(ig, inames[i]);

		rc = iscsi_init_grp_delete_initiator(ig, inames[i]);

		if (rc < 0) {

			goto cleanup;

		}
@@ -188,9 +189,9 @@ spdk_iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_in 


cleanup:

	for (; i > 0; --i) {

		rc = spdk_iscsi_init_grp_add_initiator(ig, inames[i - 1]);

		rc = iscsi_init_grp_add_initiator(ig, inames[i - 1]);

		if (rc != 0) {

			spdk_iscsi_init_grp_delete_all_initiators(ig);

			iscsi_init_grp_delete_all_initiators(ig);

			break;

		}

	}
@@ -198,7 +199,7 @@ cleanup: 
}



static struct spdk_iscsi_initiator_netmask *

spdk_iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mask)

iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mask)

{

	struct spdk_iscsi_initiator_netmask *netmask;
@@ -211,7 +212,7 @@ spdk_iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mas 
}



static int

spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)

iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)

{

	struct spdk_iscsi_initiator_netmask *imask;

	char *p;
@@ -221,7 +222,7 @@ spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask) 
		return -EPERM;

	}



	imask = spdk_iscsi_init_grp_find_netmask(ig, mask);

	imask = iscsi_init_grp_find_netmask(ig, mask);

	if (imask != NULL) {

		return -EEXIST;

	}
@@ -255,11 +256,11 @@ spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask) 
}



static int

spdk_iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask)

iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask)

{

	struct spdk_iscsi_initiator_netmask *imask;



	imask = spdk_iscsi_init_grp_find_netmask(ig, mask);

	imask = iscsi_init_grp_find_netmask(ig, mask);

	if (imask == NULL) {

		return -ENOENT;

	}
@@ -272,13 +273,13 @@ spdk_iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask) 
}



static int

spdk_iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)

iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)

{

	int i;

	int rc;



	for (i = 0; i < num_imasks; i++) {

		rc = spdk_iscsi_init_grp_add_netmask(ig, imasks[i]);

		rc = iscsi_init_grp_add_netmask(ig, imasks[i]);

		if (rc != 0) {

			goto cleanup;

		}
@@ -287,13 +288,13 @@ spdk_iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, 


cleanup:

	for (; i > 0; --i) {

		spdk_iscsi_init_grp_delete_netmask(ig, imasks[i - 1]);

		iscsi_init_grp_delete_netmask(ig, imasks[i - 1]);

	}

	return rc;

}



static void

spdk_iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig)

iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig)

{

	struct spdk_iscsi_initiator_netmask *imask, *tmp;
@@ -306,13 +307,13 @@ spdk_iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig) 
}



static int

spdk_iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)

iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)

{

	int i;

	int rc;



	for (i = 0; i < num_imasks; i++) {

		rc = spdk_iscsi_init_grp_delete_netmask(ig, imasks[i]);

		rc = iscsi_init_grp_delete_netmask(ig, imasks[i]);

		if (rc != 0) {

			goto cleanup;

		}
@@ -321,9 +322,9 @@ spdk_iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imas 


cleanup:

	for (; i > 0; --i) {

		rc = spdk_iscsi_init_grp_add_netmask(ig, imasks[i - 1]);

		rc = iscsi_init_grp_add_netmask(ig, imasks[i - 1]);

		if (rc != 0) {

			spdk_iscsi_init_grp_delete_all_netmasks(ig);

			iscsi_init_grp_delete_all_netmasks(ig);

			break;

		}

	}
@@ -332,7 +333,7 @@ cleanup: 


/* Read spdk iscsi target's config file and create initiator group */

static int

spdk_iscsi_parse_init_grp(struct spdk_conf_section *sp)

iscsi_parse_init_grp(struct spdk_conf_section *sp)

{

	int i, rc = 0;

	const char *val = NULL;
@@ -483,20 +484,20 @@ spdk_iscsi_init_grp_create_from_initiator_list(int tag, 
		      "add initiator group (from initiator list) tag=%d, #initiators=%d, #masks=%d\n",

		      tag, num_initiator_names, num_initiator_masks);



	ig = spdk_iscsi_init_grp_create(tag);

	ig = iscsi_init_grp_create(tag);

	if (!ig) {

		SPDK_ERRLOG("initiator group create error (%d)\n", tag);

		return rc;

	}



	rc = spdk_iscsi_init_grp_add_initiators(ig, num_initiator_names,

	rc = iscsi_init_grp_add_initiators(ig, num_initiator_names,

					   initiator_names);

	if (rc < 0) {

		SPDK_ERRLOG("add initiator name error\n");

		goto cleanup;

	}



	rc = spdk_iscsi_init_grp_add_netmasks(ig, num_initiator_masks,

	rc = iscsi_init_grp_add_netmasks(ig, num_initiator_masks,

					 initiator_masks);

	if (rc < 0) {

		SPDK_ERRLOG("add initiator netmask error\n");
@@ -537,18 +538,18 @@ spdk_iscsi_init_grp_add_initiators_from_initiator_list(int tag, 
		return rc;

	}



	rc = spdk_iscsi_init_grp_add_initiators(ig, num_initiator_names,

	rc = iscsi_init_grp_add_initiators(ig, num_initiator_names,

					   initiator_names);

	if (rc < 0) {

		SPDK_ERRLOG("add initiator name error\n");

		goto error;

	}



	rc = spdk_iscsi_init_grp_add_netmasks(ig, num_initiator_masks,

	rc = iscsi_init_grp_add_netmasks(ig, num_initiator_masks,

					 initiator_masks);

	if (rc < 0) {

		SPDK_ERRLOG("add initiator netmask error\n");

		spdk_iscsi_init_grp_delete_initiators(ig, num_initiator_names,

		iscsi_init_grp_delete_initiators(ig, num_initiator_names,

						 initiator_names);

	}
@@ -579,18 +580,18 @@ spdk_iscsi_init_grp_delete_initiators_from_initiator_list(int tag, 
		return rc;

	}



	rc = spdk_iscsi_init_grp_delete_initiators(ig, num_initiator_names,

	rc = iscsi_init_grp_delete_initiators(ig, num_initiator_names,

					      initiator_names);

	if (rc < 0) {

		SPDK_ERRLOG("delete initiator name error\n");

		goto error;

	}



	rc = spdk_iscsi_init_grp_delete_netmasks(ig, num_initiator_masks,

	rc = iscsi_init_grp_delete_netmasks(ig, num_initiator_masks,

					    initiator_masks);

	if (rc < 0) {

		SPDK_ERRLOG("delete initiator netmask error\n");

		spdk_iscsi_init_grp_add_initiators(ig, num_initiator_names,

		iscsi_init_grp_add_initiators(ig, num_initiator_names,

					      initiator_names);

		goto error;

	}
@@ -607,8 +608,8 @@ spdk_iscsi_init_grp_destroy(struct spdk_iscsi_init_grp *ig) 
		return;

	}



	spdk_iscsi_init_grp_delete_all_initiators(ig);

	spdk_iscsi_init_grp_delete_all_netmasks(ig);

	iscsi_init_grp_delete_all_initiators(ig);

	iscsi_init_grp_delete_all_netmasks(ig);

	free(ig);

};
@@ -639,7 +640,7 @@ spdk_iscsi_parse_init_grps(void) 
				SPDK_ERRLOG("Group 0 is invalid\n");

				return -1;

			}

			rc = spdk_iscsi_parse_init_grp(sp);

			rc = iscsi_parse_init_grp(sp);

			if (rc < 0) {

				SPDK_ERRLOG("parse_init_group() failed\n");

				return -1;
@@ -731,7 +732,7 @@ spdk_iscsi_init_grps_config_text(FILE *fp) 
}



static void

spdk_iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig,

iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig,

			 struct spdk_json_write_ctx *w)

{

	struct spdk_iscsi_initiator_name *iname;
@@ -757,7 +758,7 @@ spdk_iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig, 
}



static void

spdk_iscsi_init_grp_config_json(struct spdk_iscsi_init_grp *ig,

iscsi_init_grp_config_json(struct spdk_iscsi_init_grp *ig,

			   struct spdk_json_write_ctx *w)

{

	spdk_json_write_object_begin(w);
@@ -765,7 +766,7 @@ spdk_iscsi_init_grp_config_json(struct spdk_iscsi_init_grp *ig, 
	spdk_json_write_named_string(w, "method", "add_initiator_group");



	spdk_json_write_name(w, "params");

	spdk_iscsi_init_grp_info_json(ig, w);

	iscsi_init_grp_info_json(ig, w);



	spdk_json_write_object_end(w);

}
@@ -776,7 +777,7 @@ spdk_iscsi_init_grps_info_json(struct spdk_json_write_ctx *w) 
	struct spdk_iscsi_init_grp *ig;



	TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {

		spdk_iscsi_init_grp_info_json(ig, w);

		iscsi_init_grp_info_json(ig, w);

	}

}
@@ -786,6 +787,6 @@ spdk_iscsi_init_grps_config_json(struct spdk_json_write_ctx *w) 
	struct spdk_iscsi_init_grp *ig;



	TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {

		spdk_iscsi_init_grp_config_json(ig, w);

		iscsi_init_grp_config_json(ig, w);

	}

}

lib/iscsi/iscsi.c

+335 −352

File changed.

Preview size limit exceeded, changes collapsed.

lib/iscsi/iscsi_subsystem.c

+84 −81
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ static void *g_fini_cb_arg; 
"\n"



static void

spdk_iscsi_globals_config_text(FILE *fp)

iscsi_globals_config_text(FILE *fp)

{

	const char *authmethod = "None";

	char authgroup[32] = "None";
@@ -126,7 +126,7 @@ spdk_iscsi_globals_config_text(FILE *fp) 
#define ISCSI_DATA_BUFFER_MASK		(ISCSI_DATA_BUFFER_ALIGNMENT - 1)



static void

spdk_mobj_ctor(struct spdk_mempool *mp, __attribute__((unused)) void *arg,

mobj_ctor(struct spdk_mempool *mp, __attribute__((unused)) void *arg,

	  void *_m, __attribute__((unused)) unsigned i)

{

	struct spdk_mobj *m = _m;
@@ -142,7 +142,8 @@ spdk_mobj_ctor(struct spdk_mempool *mp, __attribute__((unused)) void *arg, 
#define IMMEDIATE_DATA_POOL_SIZE(iscsi)	(iscsi->MaxConnections * 128)

#define DATA_OUT_POOL_SIZE(iscsi)	(iscsi->MaxConnections * MAX_DATA_OUT_PER_CONNECTION)



static int spdk_iscsi_initialize_pdu_pool(void)

static int

iscsi_initialize_pdu_pool(void)

{

	struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;

	int imm_mobj_size = SPDK_BDEV_BUF_SIZE_WITH_MD(spdk_get_max_immediate_data_size()) +
@@ -164,7 +165,7 @@ static int spdk_iscsi_initialize_pdu_pool(void) 
					 IMMEDIATE_DATA_POOL_SIZE(iscsi),

					 imm_mobj_size, 256,

					 spdk_env_get_socket_id(spdk_env_get_current_core()),

					 spdk_mobj_ctor, NULL);

					 mobj_ctor, NULL);

	if (!iscsi->pdu_immediate_data_pool) {

		SPDK_ERRLOG("create PDU immediate data pool failed\n");

		return -1;
@@ -174,7 +175,7 @@ static int spdk_iscsi_initialize_pdu_pool(void) 
				   DATA_OUT_POOL_SIZE(iscsi),

				   dout_mobj_size, 256,

				   spdk_env_get_socket_id(spdk_env_get_current_core()),

				   spdk_mobj_ctor, NULL);

				   mobj_ctor, NULL);

	if (!iscsi->pdu_data_out_pool) {

		SPDK_ERRLOG("create PDU data out pool failed\n");

		return -1;
@@ -183,8 +184,9 @@ static int spdk_iscsi_initialize_pdu_pool(void) 
	return 0;

}



static void spdk_iscsi_sess_ctor(struct spdk_mempool *pool, void *arg,

				 void *session_buf, unsigned index)

static void

iscsi_sess_ctor(struct spdk_mempool *pool, void *arg, void *session_buf,

		unsigned index)

{

	struct spdk_iscsi_globals		*iscsi = arg;

	struct spdk_iscsi_sess	*sess = session_buf;
@@ -198,7 +200,7 @@ static void spdk_iscsi_sess_ctor(struct spdk_mempool *pool, void *arg, 
#define DEFAULT_TASK_POOL_SIZE 32768



static int

spdk_iscsi_initialize_task_pool(void)

iscsi_initialize_task_pool(void)

{

	struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
@@ -216,7 +218,8 @@ spdk_iscsi_initialize_task_pool(void) 
}



#define SESSION_POOL_SIZE(iscsi)	(iscsi->MaxSessions)

static int spdk_iscsi_initialize_session_pool(void)

static int

iscsi_initialize_session_pool(void)

{

	struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
@@ -224,7 +227,7 @@ static int spdk_iscsi_initialize_session_pool(void) 
			      SESSION_POOL_SIZE(iscsi),

			      sizeof(struct spdk_iscsi_sess), 0,

			      SPDK_ENV_SOCKET_ID_ANY,

			      spdk_iscsi_sess_ctor, iscsi);

			      iscsi_sess_ctor, iscsi);

	if (!iscsi->session_pool) {

		SPDK_ERRLOG("create session pool failed\n");

		return -1;
@@ -234,17 +237,17 @@ static int spdk_iscsi_initialize_session_pool(void) 
}



static int

spdk_iscsi_initialize_all_pools(void)

iscsi_initialize_all_pools(void)

{

	if (spdk_iscsi_initialize_pdu_pool() != 0) {

	if (iscsi_initialize_pdu_pool() != 0) {

		return -1;

	}



	if (spdk_iscsi_initialize_session_pool() != 0) {

	if (iscsi_initialize_session_pool() != 0) {

		return -1;

	}



	if (spdk_iscsi_initialize_task_pool() != 0) {

	if (iscsi_initialize_task_pool() != 0) {

		return -1;

	}
@@ -252,7 +255,7 @@ spdk_iscsi_initialize_all_pools(void) 
}



static void

spdk_iscsi_check_pool(struct spdk_mempool *pool, size_t count)

iscsi_check_pool(struct spdk_mempool *pool, size_t count)

{

	if (spdk_mempool_count(pool) != count) {

		SPDK_ERRLOG("spdk_mempool_count(%s) == %zu, should be %zu\n",
@@ -261,19 +264,19 @@ spdk_iscsi_check_pool(struct spdk_mempool *pool, size_t count) 
}



static void

spdk_iscsi_check_pools(void)

iscsi_check_pools(void)

{

	struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;



	spdk_iscsi_check_pool(iscsi->pdu_pool, PDU_POOL_SIZE(iscsi));

	spdk_iscsi_check_pool(iscsi->session_pool, SESSION_POOL_SIZE(iscsi));

	spdk_iscsi_check_pool(iscsi->pdu_immediate_data_pool, IMMEDIATE_DATA_POOL_SIZE(iscsi));

	spdk_iscsi_check_pool(iscsi->pdu_data_out_pool, DATA_OUT_POOL_SIZE(iscsi));

	spdk_iscsi_check_pool(iscsi->task_pool, DEFAULT_TASK_POOL_SIZE);

	iscsi_check_pool(iscsi->pdu_pool, PDU_POOL_SIZE(iscsi));

	iscsi_check_pool(iscsi->session_pool, SESSION_POOL_SIZE(iscsi));

	iscsi_check_pool(iscsi->pdu_immediate_data_pool, IMMEDIATE_DATA_POOL_SIZE(iscsi));

	iscsi_check_pool(iscsi->pdu_data_out_pool, DATA_OUT_POOL_SIZE(iscsi));

	iscsi_check_pool(iscsi->task_pool, DEFAULT_TASK_POOL_SIZE);

}



static void

spdk_iscsi_free_pools(void)

iscsi_free_pools(void)

{

	struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
@@ -328,7 +331,7 @@ struct spdk_iscsi_pdu *spdk_get_pdu(void) 
}



static void

spdk_iscsi_log_globals(void)

iscsi_log_globals(void)

{

	SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthFile %s\n",

		      g_spdk_iscsi.authfile ? g_spdk_iscsi.authfile : "(none)");
@@ -379,7 +382,7 @@ spdk_iscsi_log_globals(void) 
}



static void

spdk_iscsi_opts_init(struct spdk_iscsi_opts *opts)

iscsi_opts_init(struct spdk_iscsi_opts *opts)

{

	opts->MaxSessions = DEFAULT_MAX_SESSIONS;

	opts->MaxConnectionsPerSession = DEFAULT_MAX_CONNECTIONS_PER_SESSION;
@@ -412,7 +415,7 @@ spdk_iscsi_opts_alloc(void) 
		return NULL;

	}



	spdk_iscsi_opts_init(opts);

	iscsi_opts_init(opts);



	return opts;

}
@@ -477,7 +480,7 @@ spdk_iscsi_opts_copy(struct spdk_iscsi_opts *src) 
}



static int

spdk_iscsi_read_config_file_params(struct spdk_conf_section *sp,

iscsi_read_config_file_params(struct spdk_conf_section *sp,

			      struct spdk_iscsi_opts *opts)

{

	const char *val;
@@ -625,7 +628,7 @@ spdk_iscsi_read_config_file_params(struct spdk_conf_section *sp, 
}



static int

spdk_iscsi_opts_verify(struct spdk_iscsi_opts *opts)

iscsi_opts_verify(struct spdk_iscsi_opts *opts)

{

	if (!opts->nodebase) {

		opts->nodebase = strdup(SPDK_ISCSI_DEFAULT_NODEBASE);
@@ -703,7 +706,7 @@ spdk_iscsi_opts_verify(struct spdk_iscsi_opts *opts) 
}



static int

spdk_iscsi_parse_options(struct spdk_iscsi_opts **popts)

iscsi_parse_options(struct spdk_iscsi_opts **popts)

{

	struct spdk_iscsi_opts *opts;

	struct spdk_conf_section *sp;
@@ -716,13 +719,13 @@ spdk_iscsi_parse_options(struct spdk_iscsi_opts **popts) 
	}



	/* Process parameters */

	SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_read_config_file_parmas\n");

	SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "iscsi_read_config_file_parmas\n");

	sp = spdk_conf_find_section(NULL, "iSCSI");

	if (sp != NULL) {

		rc = spdk_iscsi_read_config_file_params(sp, opts);

		rc = iscsi_read_config_file_params(sp, opts);

		if (rc != 0) {

			free(opts);

			SPDK_ERRLOG("spdk_iscsi_read_config_file_params() failed\n");

			SPDK_ERRLOG("iscsi_read_config_file_params() failed\n");

			return rc;

		}

	}
@@ -733,11 +736,11 @@ spdk_iscsi_parse_options(struct spdk_iscsi_opts **popts) 
}



static int

spdk_iscsi_set_global_params(struct spdk_iscsi_opts *opts)

iscsi_set_global_params(struct spdk_iscsi_opts *opts)

{

	int rc;



	rc = spdk_iscsi_opts_verify(opts);

	rc = iscsi_opts_verify(opts);

	if (rc != 0) {

		SPDK_ERRLOG("spdk_iscsi_opts_verify() failed\n");

		return rc;
@@ -775,7 +778,7 @@ spdk_iscsi_set_global_params(struct spdk_iscsi_opts *opts) 


	spdk_iscsi_conn_set_min_per_core(opts->min_connections_per_core);



	spdk_iscsi_log_globals();

	iscsi_log_globals();



	return 0;

}
@@ -957,7 +960,7 @@ spdk_iscsi_find_auth_group_by_tag(int32_t tag) 
}



static void

spdk_iscsi_auth_groups_destroy(void)

iscsi_auth_groups_destroy(void)

{

	struct spdk_iscsi_auth_group *group, *tmp;
@@ -967,7 +970,7 @@ spdk_iscsi_auth_groups_destroy(void) 
}



static int

spdk_iscsi_parse_auth_group(struct spdk_conf_section *sp)

iscsi_parse_auth_group(struct spdk_conf_section *sp)

{

	int rc;

	int i;
@@ -1011,7 +1014,7 @@ spdk_iscsi_parse_auth_group(struct spdk_conf_section *sp) 
}



static int

spdk_iscsi_parse_auth_info(void)

iscsi_parse_auth_info(void)

{

	struct spdk_conf *config;

	struct spdk_conf_section *sp;
@@ -1035,15 +1038,15 @@ spdk_iscsi_parse_auth_info(void) 
		if (spdk_conf_section_match_prefix(sp, "AuthGroup")) {

			if (spdk_conf_section_get_num(sp) == 0) {

				SPDK_ERRLOG("Group 0 is invalid\n");

				spdk_iscsi_auth_groups_destroy();

				iscsi_auth_groups_destroy();

				spdk_conf_free(config);

				return -EINVAL;

			}



			rc = spdk_iscsi_parse_auth_group(sp);

			rc = iscsi_parse_auth_group(sp);

			if (rc != 0) {

				SPDK_ERRLOG("parse_auth_group() failed\n");

				spdk_iscsi_auth_groups_destroy();

				iscsi_auth_groups_destroy();

				spdk_conf_free(config);

				return rc;

			}
@@ -1056,7 +1059,7 @@ spdk_iscsi_parse_auth_info(void) 
}



static struct spdk_iscsi_auth_secret *

spdk_iscsi_find_auth_secret(const char *authuser, int ag_tag)

iscsi_find_auth_secret(const char *authuser, int ag_tag)

{

	struct spdk_iscsi_auth_group *group;

	struct spdk_iscsi_auth_secret *_secret;
@@ -1093,7 +1096,7 @@ spdk_iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser, 


	pthread_mutex_lock(&g_spdk_iscsi.mutex);



	_secret = spdk_iscsi_find_auth_secret(authuser, ag_tag);

	_secret = iscsi_find_auth_secret(authuser, ag_tag);

	if (_secret == NULL) {

		pthread_mutex_unlock(&g_spdk_iscsi.mutex);
@@ -1115,19 +1118,19 @@ spdk_iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser, 
}



static int

spdk_iscsi_initialize_global_params(void)

iscsi_initialize_global_params(void)

{

	int rc;



	if (!g_spdk_iscsi_opts) {

		rc = spdk_iscsi_parse_options(&g_spdk_iscsi_opts);

		rc = iscsi_parse_options(&g_spdk_iscsi_opts);

		if (rc != 0) {

			SPDK_ERRLOG("spdk_iscsi_parse_options() failed\n");

			return rc;

		}

	}



	rc = spdk_iscsi_set_global_params(g_spdk_iscsi_opts);

	rc = iscsi_set_global_params(g_spdk_iscsi_opts);

	if (rc != 0) {

		SPDK_ERRLOG("spdk_iscsi_set_global_params() failed\n");

	}
@@ -1139,7 +1142,7 @@ spdk_iscsi_initialize_global_params(void) 
}



static void

spdk_iscsi_init_complete(int rc)

iscsi_init_complete(int rc)

{

	spdk_iscsi_init_cb cb_fn = g_init_cb_fn;

	void *cb_arg = g_init_cb_arg;
@@ -1151,7 +1154,7 @@ spdk_iscsi_init_complete(int rc) 
}



static int

spdk_iscsi_poll_group_poll(void *ctx)

iscsi_poll_group_poll(void *ctx)

{

	struct spdk_iscsi_poll_group *group = ctx;

	struct spdk_iscsi_conn *conn, *tmp;
@@ -1176,7 +1179,7 @@ spdk_iscsi_poll_group_poll(void *ctx) 
}



static int

spdk_iscsi_poll_group_handle_nop(void *ctx)

iscsi_poll_group_handle_nop(void *ctx)

{

	struct spdk_iscsi_poll_group *group = ctx;

	struct spdk_iscsi_conn *conn, *tmp;
@@ -1201,9 +1204,9 @@ iscsi_create_poll_group(void *ctx) 
	pg->sock_group = spdk_sock_group_create();

	assert(pg->sock_group != NULL);



	pg->poller = spdk_poller_register(spdk_iscsi_poll_group_poll, pg, 0);

	pg->poller = spdk_poller_register(iscsi_poll_group_poll, pg, 0);

	/* set the period to 1 sec */

	pg->nop_poller = spdk_poller_register(spdk_iscsi_poll_group_handle_nop, pg, 1000000);

	pg->nop_poller = spdk_poller_register(iscsi_poll_group_handle_nop, pg, 1000000);

}



static void
@@ -1222,14 +1225,14 @@ iscsi_unregister_poll_group(void *ctx) 
}



static void

spdk_initialize_iscsi_poll_group(spdk_msg_fn cpl)

initialize_iscsi_poll_group(spdk_msg_fn cpl)

{

	size_t g_num_poll_groups = spdk_env_get_last_core() + 1;



	g_spdk_iscsi.poll_group = calloc(g_num_poll_groups, sizeof(struct spdk_iscsi_poll_group));

	if (!g_spdk_iscsi.poll_group) {

		SPDK_ERRLOG("Failed to allocated iscsi poll group\n");

		spdk_iscsi_init_complete(-1);

		iscsi_init_complete(-1);

		return;

	}
@@ -1238,7 +1241,7 @@ spdk_initialize_iscsi_poll_group(spdk_msg_fn cpl) 
}



static void

spdk_iscsi_parse_configuration(void *ctx)

iscsi_parse_configuration(void *ctx)

{

	int rc;
@@ -1261,7 +1264,7 @@ spdk_iscsi_parse_configuration(void *ctx) 


	if (g_spdk_iscsi.authfile != NULL) {

		if (access(g_spdk_iscsi.authfile, R_OK) == 0) {

			rc = spdk_iscsi_parse_auth_info();

			rc = iscsi_parse_auth_info();

			if (rc < 0) {

				SPDK_ERRLOG("spdk_iscsi_parse_auth_info() failed\n");

			}
@@ -1272,15 +1275,15 @@ spdk_iscsi_parse_configuration(void *ctx) 
	}



end:

	spdk_iscsi_init_complete(rc);

	iscsi_init_complete(rc);

}



static int

spdk_iscsi_parse_globals(void)

iscsi_parse_globals(void)

{

	int rc;



	rc = spdk_iscsi_initialize_global_params();

	rc = iscsi_initialize_global_params();

	if (rc != 0) {

		SPDK_ERRLOG("spdk_iscsi_initialize_iscsi_global_params() failed\n");

		return rc;
@@ -1300,7 +1303,7 @@ spdk_iscsi_parse_globals(void) 
	 */

	g_spdk_iscsi.MaxConnections = g_spdk_iscsi.MaxSessions;



	rc = spdk_iscsi_initialize_all_pools();

	rc = iscsi_initialize_all_pools();

	if (rc != 0) {

		SPDK_ERRLOG("spdk_initialize_all_pools() failed\n");

		return -1;
@@ -1312,7 +1315,7 @@ spdk_iscsi_parse_globals(void) 
		return rc;

	}



	spdk_initialize_iscsi_poll_group(spdk_iscsi_parse_configuration);

	initialize_iscsi_poll_group(iscsi_parse_configuration);

	return 0;

}
@@ -1325,10 +1328,10 @@ spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg) 
	g_init_cb_fn = cb_fn;

	g_init_cb_arg = cb_arg;



	rc = spdk_iscsi_parse_globals();

	rc = iscsi_parse_globals();

	if (rc < 0) {

		SPDK_ERRLOG("spdk_iscsi_parse_globals() failed\n");

		spdk_iscsi_init_complete(-1);

		iscsi_init_complete(-1);

	}



	/*
@@ -1349,15 +1352,15 @@ spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg) 
}



static void

spdk_iscsi_fini_done(void *arg)

iscsi_fini_done(void *arg)

{

	spdk_iscsi_check_pools();

	spdk_iscsi_free_pools();

	iscsi_check_pools();

	iscsi_free_pools();



	spdk_iscsi_shutdown_tgt_nodes();

	spdk_iscsi_init_grps_destroy();

	spdk_iscsi_portal_grps_destroy();

	spdk_iscsi_auth_groups_destroy();

	iscsi_auth_groups_destroy();

	free(g_spdk_iscsi.authfile);

	free(g_spdk_iscsi.nodebase);

	free(g_spdk_iscsi.poll_group);
@@ -1370,16 +1373,16 @@ void 
spdk_shutdown_iscsi_conns_done(void)

{

	if (g_spdk_iscsi.poll_group) {

		spdk_for_each_thread(iscsi_unregister_poll_group, NULL, spdk_iscsi_fini_done);

		spdk_for_each_thread(iscsi_unregister_poll_group, NULL, iscsi_fini_done);

	} else {

		spdk_iscsi_fini_done(NULL);

		iscsi_fini_done(NULL);

	}

}



void

spdk_iscsi_config_text(FILE *fp)

{

	spdk_iscsi_globals_config_text(fp);

	iscsi_globals_config_text(fp);

	spdk_iscsi_portal_grps_config_text(fp);

	spdk_iscsi_init_grps_config_text(fp);

	spdk_iscsi_tgt_nodes_config_text(fp);
@@ -1427,7 +1430,7 @@ spdk_iscsi_opts_info_json(struct spdk_json_write_ctx *w) 
}



static void

spdk_iscsi_auth_group_info_json(struct spdk_iscsi_auth_group *group,

iscsi_auth_group_info_json(struct spdk_iscsi_auth_group *group,

			   struct spdk_json_write_ctx *w)

{

	struct spdk_iscsi_auth_secret *_secret;
@@ -1456,7 +1459,7 @@ spdk_iscsi_auth_group_info_json(struct spdk_iscsi_auth_group *group, 
}



static void

spdk_iscsi_auth_group_config_json(struct spdk_iscsi_auth_group *group,

iscsi_auth_group_config_json(struct spdk_iscsi_auth_group *group,

			     struct spdk_json_write_ctx *w)

{

	spdk_json_write_object_begin(w);
@@ -1464,7 +1467,7 @@ spdk_iscsi_auth_group_config_json(struct spdk_iscsi_auth_group *group, 
	spdk_json_write_named_string(w, "method", "add_iscsi_auth_group");



	spdk_json_write_name(w, "params");

	spdk_iscsi_auth_group_info_json(group, w);

	iscsi_auth_group_info_json(group, w);



	spdk_json_write_object_end(w);

}
@@ -1475,22 +1478,22 @@ spdk_iscsi_auth_groups_info_json(struct spdk_json_write_ctx *w) 
	struct spdk_iscsi_auth_group *group;



	TAILQ_FOREACH(group, &g_spdk_iscsi.auth_group_head, tailq) {

		spdk_iscsi_auth_group_info_json(group, w);

		iscsi_auth_group_info_json(group, w);

	}

}



static void

spdk_iscsi_auth_groups_config_json(struct spdk_json_write_ctx *w)

iscsi_auth_groups_config_json(struct spdk_json_write_ctx *w)

{

	struct spdk_iscsi_auth_group *group;



	TAILQ_FOREACH(group, &g_spdk_iscsi.auth_group_head, tailq) {

		spdk_iscsi_auth_group_config_json(group, w);

		iscsi_auth_group_config_json(group, w);

	}

}



static void

spdk_iscsi_opts_config_json(struct spdk_json_write_ctx *w)

iscsi_opts_config_json(struct spdk_json_write_ctx *w)

{

	spdk_json_write_object_begin(w);
@@ -1506,11 +1509,11 @@ void 
spdk_iscsi_config_json(struct spdk_json_write_ctx *w)

{

	spdk_json_write_array_begin(w);

	spdk_iscsi_opts_config_json(w);

	iscsi_opts_config_json(w);

	spdk_iscsi_portal_grps_config_json(w);

	spdk_iscsi_init_grps_config_json(w);

	spdk_iscsi_tgt_nodes_config_json(w);

	spdk_iscsi_auth_groups_config_json(w);

	iscsi_auth_groups_config_json(w);

	spdk_json_write_array_end(w);

}